strongdm.models
View Source
0# Copyright 2020 StrongDM Inc 1# 2# Licensed under the Apache License, Version 2.0 (the "License"); 3# you may not use this file except in compliance with the License. 4# You may obtain a copy of the License at 5# 6# http://www.apache.org/licenses/LICENSE-2.0 7# 8# Unless required by applicable law or agreed to in writing, software 9# distributed under the License is distributed on an "AS IS" BASIS, 10# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11# See the License for the specific language governing permissions and 12# limitations under the License. 13# 14 15# This file was generated by protogen. DO NOT EDIT. 16 17import collections 18 19 20class AKS: 21 ''' 22 23 ''' 24 __slots__ = [ 25 'certificate_authority', 26 'client_certificate', 27 'client_key', 28 'egress_filter', 29 'healthcheck_namespace', 30 'healthy', 31 'hostname', 32 'id', 33 'name', 34 'port', 35 'secret_store_id', 36 'tags', 37 ] 38 39 def __init__( 40 self, 41 certificate_authority=None, 42 client_certificate=None, 43 client_key=None, 44 egress_filter=None, 45 healthcheck_namespace=None, 46 healthy=None, 47 hostname=None, 48 id=None, 49 name=None, 50 port=None, 51 secret_store_id=None, 52 tags=None, 53 ): 54 self.certificate_authority = certificate_authority if certificate_authority is not None else '' 55 ''' 56 57 ''' 58 self.client_certificate = client_certificate if client_certificate is not None else '' 59 ''' 60 61 ''' 62 self.client_key = client_key if client_key is not None else '' 63 ''' 64 65 ''' 66 self.egress_filter = egress_filter if egress_filter is not None else '' 67 ''' 68 A filter applied to the routing logic to pin datasource to nodes. 69 ''' 70 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 71 ''' 72 The path used to check the health of your connection. Defaults to `default`. 73 ''' 74 self.healthy = healthy if healthy is not None else False 75 ''' 76 True if the datasource is reachable and the credentials are valid. 77 ''' 78 self.hostname = hostname if hostname is not None else '' 79 ''' 80 81 ''' 82 self.id = id if id is not None else '' 83 ''' 84 Unique identifier of the Resource. 85 ''' 86 self.name = name if name is not None else '' 87 ''' 88 Unique human-readable name of the Resource. 89 ''' 90 self.port = port if port is not None else 0 91 ''' 92 93 ''' 94 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 95 ''' 96 ID of the secret store containing credentials for this resource, if any. 97 ''' 98 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 99 ''' 100 Tags is a map of key, value pairs. 101 ''' 102 103 def __repr__(self): 104 return '<sdm.AKS ' + \ 105 'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\ 106 'client_certificate: ' + repr(self.client_certificate) + ' ' +\ 107 'client_key: ' + repr(self.client_key) + ' ' +\ 108 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 109 'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\ 110 'healthy: ' + repr(self.healthy) + ' ' +\ 111 'hostname: ' + repr(self.hostname) + ' ' +\ 112 'id: ' + repr(self.id) + ' ' +\ 113 'name: ' + repr(self.name) + ' ' +\ 114 'port: ' + repr(self.port) + ' ' +\ 115 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 116 'tags: ' + repr(self.tags) + ' ' +\ 117 '>' 118 119 def to_dict(self): 120 return { 121 'certificate_authority': self.certificate_authority, 122 'client_certificate': self.client_certificate, 123 'client_key': self.client_key, 124 'egress_filter': self.egress_filter, 125 'healthcheck_namespace': self.healthcheck_namespace, 126 'healthy': self.healthy, 127 'hostname': self.hostname, 128 'id': self.id, 129 'name': self.name, 130 'port': self.port, 131 'secret_store_id': self.secret_store_id, 132 'tags': self.tags, 133 } 134 135 @classmethod 136 def from_dict(cls, d): 137 return cls( 138 certificate_authority=d.get('certificate_authority'), 139 client_certificate=d.get('client_certificate'), 140 client_key=d.get('client_key'), 141 egress_filter=d.get('egress_filter'), 142 healthcheck_namespace=d.get('healthcheck_namespace'), 143 healthy=d.get('healthy'), 144 hostname=d.get('hostname'), 145 id=d.get('id'), 146 name=d.get('name'), 147 port=d.get('port'), 148 secret_store_id=d.get('secret_store_id'), 149 tags=d.get('tags'), 150 ) 151 152 153class AKSBasicAuth: 154 ''' 155 156 ''' 157 __slots__ = [ 158 'egress_filter', 159 'healthcheck_namespace', 160 'healthy', 161 'hostname', 162 'id', 163 'name', 164 'password', 165 'port', 166 'secret_store_id', 167 'tags', 168 'username', 169 ] 170 171 def __init__( 172 self, 173 egress_filter=None, 174 healthcheck_namespace=None, 175 healthy=None, 176 hostname=None, 177 id=None, 178 name=None, 179 password=None, 180 port=None, 181 secret_store_id=None, 182 tags=None, 183 username=None, 184 ): 185 self.egress_filter = egress_filter if egress_filter is not None else '' 186 ''' 187 A filter applied to the routing logic to pin datasource to nodes. 188 ''' 189 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 190 ''' 191 The path used to check the health of your connection. Defaults to `default`. 192 ''' 193 self.healthy = healthy if healthy is not None else False 194 ''' 195 True if the datasource is reachable and the credentials are valid. 196 ''' 197 self.hostname = hostname if hostname is not None else '' 198 ''' 199 200 ''' 201 self.id = id if id is not None else '' 202 ''' 203 Unique identifier of the Resource. 204 ''' 205 self.name = name if name is not None else '' 206 ''' 207 Unique human-readable name of the Resource. 208 ''' 209 self.password = password if password is not None else '' 210 ''' 211 212 ''' 213 self.port = port if port is not None else 0 214 ''' 215 216 ''' 217 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 218 ''' 219 ID of the secret store containing credentials for this resource, if any. 220 ''' 221 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 222 ''' 223 Tags is a map of key, value pairs. 224 ''' 225 self.username = username if username is not None else '' 226 ''' 227 228 ''' 229 230 def __repr__(self): 231 return '<sdm.AKSBasicAuth ' + \ 232 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 233 'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\ 234 'healthy: ' + repr(self.healthy) + ' ' +\ 235 'hostname: ' + repr(self.hostname) + ' ' +\ 236 'id: ' + repr(self.id) + ' ' +\ 237 'name: ' + repr(self.name) + ' ' +\ 238 'password: ' + repr(self.password) + ' ' +\ 239 'port: ' + repr(self.port) + ' ' +\ 240 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 241 'tags: ' + repr(self.tags) + ' ' +\ 242 'username: ' + repr(self.username) + ' ' +\ 243 '>' 244 245 def to_dict(self): 246 return { 247 'egress_filter': self.egress_filter, 248 'healthcheck_namespace': self.healthcheck_namespace, 249 'healthy': self.healthy, 250 'hostname': self.hostname, 251 'id': self.id, 252 'name': self.name, 253 'password': self.password, 254 'port': self.port, 255 'secret_store_id': self.secret_store_id, 256 'tags': self.tags, 257 'username': self.username, 258 } 259 260 @classmethod 261 def from_dict(cls, d): 262 return cls( 263 egress_filter=d.get('egress_filter'), 264 healthcheck_namespace=d.get('healthcheck_namespace'), 265 healthy=d.get('healthy'), 266 hostname=d.get('hostname'), 267 id=d.get('id'), 268 name=d.get('name'), 269 password=d.get('password'), 270 port=d.get('port'), 271 secret_store_id=d.get('secret_store_id'), 272 tags=d.get('tags'), 273 username=d.get('username'), 274 ) 275 276 277class AKSServiceAccount: 278 ''' 279 280 ''' 281 __slots__ = [ 282 'egress_filter', 283 'healthcheck_namespace', 284 'healthy', 285 'hostname', 286 'id', 287 'name', 288 'port', 289 'secret_store_id', 290 'tags', 291 'token', 292 ] 293 294 def __init__( 295 self, 296 egress_filter=None, 297 healthcheck_namespace=None, 298 healthy=None, 299 hostname=None, 300 id=None, 301 name=None, 302 port=None, 303 secret_store_id=None, 304 tags=None, 305 token=None, 306 ): 307 self.egress_filter = egress_filter if egress_filter is not None else '' 308 ''' 309 A filter applied to the routing logic to pin datasource to nodes. 310 ''' 311 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 312 ''' 313 The path used to check the health of your connection. Defaults to `default`. 314 ''' 315 self.healthy = healthy if healthy is not None else False 316 ''' 317 True if the datasource is reachable and the credentials are valid. 318 ''' 319 self.hostname = hostname if hostname is not None else '' 320 ''' 321 322 ''' 323 self.id = id if id is not None else '' 324 ''' 325 Unique identifier of the Resource. 326 ''' 327 self.name = name if name is not None else '' 328 ''' 329 Unique human-readable name of the Resource. 330 ''' 331 self.port = port if port is not None else 0 332 ''' 333 334 ''' 335 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 336 ''' 337 ID of the secret store containing credentials for this resource, if any. 338 ''' 339 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 340 ''' 341 Tags is a map of key, value pairs. 342 ''' 343 self.token = token if token is not None else '' 344 ''' 345 346 ''' 347 348 def __repr__(self): 349 return '<sdm.AKSServiceAccount ' + \ 350 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 351 'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\ 352 'healthy: ' + repr(self.healthy) + ' ' +\ 353 'hostname: ' + repr(self.hostname) + ' ' +\ 354 'id: ' + repr(self.id) + ' ' +\ 355 'name: ' + repr(self.name) + ' ' +\ 356 'port: ' + repr(self.port) + ' ' +\ 357 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 358 'tags: ' + repr(self.tags) + ' ' +\ 359 'token: ' + repr(self.token) + ' ' +\ 360 '>' 361 362 def to_dict(self): 363 return { 364 'egress_filter': self.egress_filter, 365 'healthcheck_namespace': self.healthcheck_namespace, 366 'healthy': self.healthy, 367 'hostname': self.hostname, 368 'id': self.id, 369 'name': self.name, 370 'port': self.port, 371 'secret_store_id': self.secret_store_id, 372 'tags': self.tags, 373 'token': self.token, 374 } 375 376 @classmethod 377 def from_dict(cls, d): 378 return cls( 379 egress_filter=d.get('egress_filter'), 380 healthcheck_namespace=d.get('healthcheck_namespace'), 381 healthy=d.get('healthy'), 382 hostname=d.get('hostname'), 383 id=d.get('id'), 384 name=d.get('name'), 385 port=d.get('port'), 386 secret_store_id=d.get('secret_store_id'), 387 tags=d.get('tags'), 388 token=d.get('token'), 389 ) 390 391 392class AKSServiceAccountUserImpersonation: 393 ''' 394 395 ''' 396 __slots__ = [ 397 'egress_filter', 398 'healthcheck_namespace', 399 'healthy', 400 'hostname', 401 'id', 402 'name', 403 'port', 404 'secret_store_id', 405 'tags', 406 'token', 407 ] 408 409 def __init__( 410 self, 411 egress_filter=None, 412 healthcheck_namespace=None, 413 healthy=None, 414 hostname=None, 415 id=None, 416 name=None, 417 port=None, 418 secret_store_id=None, 419 tags=None, 420 token=None, 421 ): 422 self.egress_filter = egress_filter if egress_filter is not None else '' 423 ''' 424 A filter applied to the routing logic to pin datasource to nodes. 425 ''' 426 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 427 ''' 428 The path used to check the health of your connection. Defaults to `default`. 429 ''' 430 self.healthy = healthy if healthy is not None else False 431 ''' 432 True if the datasource is reachable and the credentials are valid. 433 ''' 434 self.hostname = hostname if hostname is not None else '' 435 ''' 436 437 ''' 438 self.id = id if id is not None else '' 439 ''' 440 Unique identifier of the Resource. 441 ''' 442 self.name = name if name is not None else '' 443 ''' 444 Unique human-readable name of the Resource. 445 ''' 446 self.port = port if port is not None else 0 447 ''' 448 449 ''' 450 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 451 ''' 452 ID of the secret store containing credentials for this resource, if any. 453 ''' 454 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 455 ''' 456 Tags is a map of key, value pairs. 457 ''' 458 self.token = token if token is not None else '' 459 ''' 460 461 ''' 462 463 def __repr__(self): 464 return '<sdm.AKSServiceAccountUserImpersonation ' + \ 465 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 466 'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\ 467 'healthy: ' + repr(self.healthy) + ' ' +\ 468 'hostname: ' + repr(self.hostname) + ' ' +\ 469 'id: ' + repr(self.id) + ' ' +\ 470 'name: ' + repr(self.name) + ' ' +\ 471 'port: ' + repr(self.port) + ' ' +\ 472 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 473 'tags: ' + repr(self.tags) + ' ' +\ 474 'token: ' + repr(self.token) + ' ' +\ 475 '>' 476 477 def to_dict(self): 478 return { 479 'egress_filter': self.egress_filter, 480 'healthcheck_namespace': self.healthcheck_namespace, 481 'healthy': self.healthy, 482 'hostname': self.hostname, 483 'id': self.id, 484 'name': self.name, 485 'port': self.port, 486 'secret_store_id': self.secret_store_id, 487 'tags': self.tags, 488 'token': self.token, 489 } 490 491 @classmethod 492 def from_dict(cls, d): 493 return cls( 494 egress_filter=d.get('egress_filter'), 495 healthcheck_namespace=d.get('healthcheck_namespace'), 496 healthy=d.get('healthy'), 497 hostname=d.get('hostname'), 498 id=d.get('id'), 499 name=d.get('name'), 500 port=d.get('port'), 501 secret_store_id=d.get('secret_store_id'), 502 tags=d.get('tags'), 503 token=d.get('token'), 504 ) 505 506 507class AKSUserImpersonation: 508 ''' 509 510 ''' 511 __slots__ = [ 512 'certificate_authority', 513 'client_certificate', 514 'client_key', 515 'egress_filter', 516 'healthcheck_namespace', 517 'healthy', 518 'hostname', 519 'id', 520 'name', 521 'port', 522 'secret_store_id', 523 'tags', 524 ] 525 526 def __init__( 527 self, 528 certificate_authority=None, 529 client_certificate=None, 530 client_key=None, 531 egress_filter=None, 532 healthcheck_namespace=None, 533 healthy=None, 534 hostname=None, 535 id=None, 536 name=None, 537 port=None, 538 secret_store_id=None, 539 tags=None, 540 ): 541 self.certificate_authority = certificate_authority if certificate_authority is not None else '' 542 ''' 543 544 ''' 545 self.client_certificate = client_certificate if client_certificate is not None else '' 546 ''' 547 548 ''' 549 self.client_key = client_key if client_key is not None else '' 550 ''' 551 552 ''' 553 self.egress_filter = egress_filter if egress_filter is not None else '' 554 ''' 555 A filter applied to the routing logic to pin datasource to nodes. 556 ''' 557 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 558 ''' 559 The path used to check the health of your connection. Defaults to `default`. 560 ''' 561 self.healthy = healthy if healthy is not None else False 562 ''' 563 True if the datasource is reachable and the credentials are valid. 564 ''' 565 self.hostname = hostname if hostname is not None else '' 566 ''' 567 568 ''' 569 self.id = id if id is not None else '' 570 ''' 571 Unique identifier of the Resource. 572 ''' 573 self.name = name if name is not None else '' 574 ''' 575 Unique human-readable name of the Resource. 576 ''' 577 self.port = port if port is not None else 0 578 ''' 579 580 ''' 581 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 582 ''' 583 ID of the secret store containing credentials for this resource, if any. 584 ''' 585 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 586 ''' 587 Tags is a map of key, value pairs. 588 ''' 589 590 def __repr__(self): 591 return '<sdm.AKSUserImpersonation ' + \ 592 'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\ 593 'client_certificate: ' + repr(self.client_certificate) + ' ' +\ 594 'client_key: ' + repr(self.client_key) + ' ' +\ 595 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 596 'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\ 597 'healthy: ' + repr(self.healthy) + ' ' +\ 598 'hostname: ' + repr(self.hostname) + ' ' +\ 599 'id: ' + repr(self.id) + ' ' +\ 600 'name: ' + repr(self.name) + ' ' +\ 601 'port: ' + repr(self.port) + ' ' +\ 602 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 603 'tags: ' + repr(self.tags) + ' ' +\ 604 '>' 605 606 def to_dict(self): 607 return { 608 'certificate_authority': self.certificate_authority, 609 'client_certificate': self.client_certificate, 610 'client_key': self.client_key, 611 'egress_filter': self.egress_filter, 612 'healthcheck_namespace': self.healthcheck_namespace, 613 'healthy': self.healthy, 614 'hostname': self.hostname, 615 'id': self.id, 616 'name': self.name, 617 'port': self.port, 618 'secret_store_id': self.secret_store_id, 619 'tags': self.tags, 620 } 621 622 @classmethod 623 def from_dict(cls, d): 624 return cls( 625 certificate_authority=d.get('certificate_authority'), 626 client_certificate=d.get('client_certificate'), 627 client_key=d.get('client_key'), 628 egress_filter=d.get('egress_filter'), 629 healthcheck_namespace=d.get('healthcheck_namespace'), 630 healthy=d.get('healthy'), 631 hostname=d.get('hostname'), 632 id=d.get('id'), 633 name=d.get('name'), 634 port=d.get('port'), 635 secret_store_id=d.get('secret_store_id'), 636 tags=d.get('tags'), 637 ) 638 639 640class AWS: 641 ''' 642 643 ''' 644 __slots__ = [ 645 'access_key', 646 'egress_filter', 647 'healthcheck_region', 648 'healthy', 649 'id', 650 'name', 651 'role_arn', 652 'role_external_id', 653 'secret_access_key', 654 'secret_store_id', 655 'tags', 656 ] 657 658 def __init__( 659 self, 660 access_key=None, 661 egress_filter=None, 662 healthcheck_region=None, 663 healthy=None, 664 id=None, 665 name=None, 666 role_arn=None, 667 role_external_id=None, 668 secret_access_key=None, 669 secret_store_id=None, 670 tags=None, 671 ): 672 self.access_key = access_key if access_key is not None else '' 673 ''' 674 675 ''' 676 self.egress_filter = egress_filter if egress_filter is not None else '' 677 ''' 678 A filter applied to the routing logic to pin datasource to nodes. 679 ''' 680 self.healthcheck_region = healthcheck_region if healthcheck_region is not None else '' 681 ''' 682 683 ''' 684 self.healthy = healthy if healthy is not None else False 685 ''' 686 True if the datasource is reachable and the credentials are valid. 687 ''' 688 self.id = id if id is not None else '' 689 ''' 690 Unique identifier of the Resource. 691 ''' 692 self.name = name if name is not None else '' 693 ''' 694 Unique human-readable name of the Resource. 695 ''' 696 self.role_arn = role_arn if role_arn is not None else '' 697 ''' 698 699 ''' 700 self.role_external_id = role_external_id if role_external_id is not None else '' 701 ''' 702 703 ''' 704 self.secret_access_key = secret_access_key if secret_access_key is not None else '' 705 ''' 706 707 ''' 708 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 709 ''' 710 ID of the secret store containing credentials for this resource, if any. 711 ''' 712 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 713 ''' 714 Tags is a map of key, value pairs. 715 ''' 716 717 def __repr__(self): 718 return '<sdm.AWS ' + \ 719 'access_key: ' + repr(self.access_key) + ' ' +\ 720 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 721 'healthcheck_region: ' + repr(self.healthcheck_region) + ' ' +\ 722 'healthy: ' + repr(self.healthy) + ' ' +\ 723 'id: ' + repr(self.id) + ' ' +\ 724 'name: ' + repr(self.name) + ' ' +\ 725 'role_arn: ' + repr(self.role_arn) + ' ' +\ 726 'role_external_id: ' + repr(self.role_external_id) + ' ' +\ 727 'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\ 728 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 729 'tags: ' + repr(self.tags) + ' ' +\ 730 '>' 731 732 def to_dict(self): 733 return { 734 'access_key': self.access_key, 735 'egress_filter': self.egress_filter, 736 'healthcheck_region': self.healthcheck_region, 737 'healthy': self.healthy, 738 'id': self.id, 739 'name': self.name, 740 'role_arn': self.role_arn, 741 'role_external_id': self.role_external_id, 742 'secret_access_key': self.secret_access_key, 743 'secret_store_id': self.secret_store_id, 744 'tags': self.tags, 745 } 746 747 @classmethod 748 def from_dict(cls, d): 749 return cls( 750 access_key=d.get('access_key'), 751 egress_filter=d.get('egress_filter'), 752 healthcheck_region=d.get('healthcheck_region'), 753 healthy=d.get('healthy'), 754 id=d.get('id'), 755 name=d.get('name'), 756 role_arn=d.get('role_arn'), 757 role_external_id=d.get('role_external_id'), 758 secret_access_key=d.get('secret_access_key'), 759 secret_store_id=d.get('secret_store_id'), 760 tags=d.get('tags'), 761 ) 762 763 764class AWSStore: 765 ''' 766 767 ''' 768 __slots__ = [ 769 'id', 770 'name', 771 'region', 772 'tags', 773 ] 774 775 def __init__( 776 self, 777 id=None, 778 name=None, 779 region=None, 780 tags=None, 781 ): 782 self.id = id if id is not None else '' 783 ''' 784 Unique identifier of the SecretStore. 785 ''' 786 self.name = name if name is not None else '' 787 ''' 788 Unique human-readable name of the SecretStore. 789 ''' 790 self.region = region if region is not None else '' 791 ''' 792 793 ''' 794 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 795 ''' 796 Tags is a map of key, value pairs. 797 ''' 798 799 def __repr__(self): 800 return '<sdm.AWSStore ' + \ 801 'id: ' + repr(self.id) + ' ' +\ 802 'name: ' + repr(self.name) + ' ' +\ 803 'region: ' + repr(self.region) + ' ' +\ 804 'tags: ' + repr(self.tags) + ' ' +\ 805 '>' 806 807 def to_dict(self): 808 return { 809 'id': self.id, 810 'name': self.name, 811 'region': self.region, 812 'tags': self.tags, 813 } 814 815 @classmethod 816 def from_dict(cls, d): 817 return cls( 818 id=d.get('id'), 819 name=d.get('name'), 820 region=d.get('region'), 821 tags=d.get('tags'), 822 ) 823 824 825class AccountAttachment: 826 ''' 827 AccountAttachments assign an account to a role. 828 ''' 829 __slots__ = [ 830 'account_id', 831 'id', 832 'role_id', 833 ] 834 835 def __init__( 836 self, 837 account_id=None, 838 id=None, 839 role_id=None, 840 ): 841 self.account_id = account_id if account_id is not None else '' 842 ''' 843 The id of the account of this AccountAttachment. 844 ''' 845 self.id = id if id is not None else '' 846 ''' 847 Unique identifier of the AccountAttachment. 848 ''' 849 self.role_id = role_id if role_id is not None else '' 850 ''' 851 The id of the attached role of this AccountAttachment. 852 ''' 853 854 def __repr__(self): 855 return '<sdm.AccountAttachment ' + \ 856 'account_id: ' + repr(self.account_id) + ' ' +\ 857 'id: ' + repr(self.id) + ' ' +\ 858 'role_id: ' + repr(self.role_id) + ' ' +\ 859 '>' 860 861 def to_dict(self): 862 return { 863 'account_id': self.account_id, 864 'id': self.id, 865 'role_id': self.role_id, 866 } 867 868 @classmethod 869 def from_dict(cls, d): 870 return cls( 871 account_id=d.get('account_id'), 872 id=d.get('id'), 873 role_id=d.get('role_id'), 874 ) 875 876 877class AccountAttachmentCreateResponse: 878 ''' 879 AccountAttachmentCreateResponse reports how the AccountAttachments were created in the system. 880 ''' 881 __slots__ = [ 882 'account_attachment', 883 'meta', 884 'rate_limit', 885 ] 886 887 def __init__( 888 self, 889 account_attachment=None, 890 meta=None, 891 rate_limit=None, 892 ): 893 self.account_attachment = account_attachment if account_attachment is not None else None 894 ''' 895 The created AccountAttachment. 896 ''' 897 self.meta = meta if meta is not None else None 898 ''' 899 Reserved for future use. 900 ''' 901 self.rate_limit = rate_limit if rate_limit is not None else None 902 ''' 903 Rate limit information. 904 ''' 905 906 def __repr__(self): 907 return '<sdm.AccountAttachmentCreateResponse ' + \ 908 'account_attachment: ' + repr(self.account_attachment) + ' ' +\ 909 'meta: ' + repr(self.meta) + ' ' +\ 910 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 911 '>' 912 913 def to_dict(self): 914 return { 915 'account_attachment': self.account_attachment, 916 'meta': self.meta, 917 'rate_limit': self.rate_limit, 918 } 919 920 @classmethod 921 def from_dict(cls, d): 922 return cls( 923 account_attachment=d.get('account_attachment'), 924 meta=d.get('meta'), 925 rate_limit=d.get('rate_limit'), 926 ) 927 928 929class AccountAttachmentDeleteResponse: 930 ''' 931 AccountAttachmentDeleteResponse returns information about a AccountAttachment that was deleted. 932 ''' 933 __slots__ = [ 934 'meta', 935 'rate_limit', 936 ] 937 938 def __init__( 939 self, 940 meta=None, 941 rate_limit=None, 942 ): 943 self.meta = meta if meta is not None else None 944 ''' 945 Reserved for future use. 946 ''' 947 self.rate_limit = rate_limit if rate_limit is not None else None 948 ''' 949 Rate limit information. 950 ''' 951 952 def __repr__(self): 953 return '<sdm.AccountAttachmentDeleteResponse ' + \ 954 'meta: ' + repr(self.meta) + ' ' +\ 955 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 956 '>' 957 958 def to_dict(self): 959 return { 960 'meta': self.meta, 961 'rate_limit': self.rate_limit, 962 } 963 964 @classmethod 965 def from_dict(cls, d): 966 return cls( 967 meta=d.get('meta'), 968 rate_limit=d.get('rate_limit'), 969 ) 970 971 972class AccountAttachmentGetResponse: 973 ''' 974 AccountAttachmentGetResponse returns a requested AccountAttachment. 975 ''' 976 __slots__ = [ 977 'account_attachment', 978 'meta', 979 'rate_limit', 980 ] 981 982 def __init__( 983 self, 984 account_attachment=None, 985 meta=None, 986 rate_limit=None, 987 ): 988 self.account_attachment = account_attachment if account_attachment is not None else None 989 ''' 990 The requested AccountAttachment. 991 ''' 992 self.meta = meta if meta is not None else None 993 ''' 994 Reserved for future use. 995 ''' 996 self.rate_limit = rate_limit if rate_limit is not None else None 997 ''' 998 Rate limit information. 999 ''' 1000 1001 def __repr__(self): 1002 return '<sdm.AccountAttachmentGetResponse ' + \ 1003 'account_attachment: ' + repr(self.account_attachment) + ' ' +\ 1004 'meta: ' + repr(self.meta) + ' ' +\ 1005 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 1006 '>' 1007 1008 def to_dict(self): 1009 return { 1010 'account_attachment': self.account_attachment, 1011 'meta': self.meta, 1012 'rate_limit': self.rate_limit, 1013 } 1014 1015 @classmethod 1016 def from_dict(cls, d): 1017 return cls( 1018 account_attachment=d.get('account_attachment'), 1019 meta=d.get('meta'), 1020 rate_limit=d.get('rate_limit'), 1021 ) 1022 1023 1024class AccountCreateResponse: 1025 ''' 1026 AccountCreateResponse reports how the Accounts were created in the system. 1027 ''' 1028 __slots__ = [ 1029 'account', 1030 'meta', 1031 'rate_limit', 1032 'token', 1033 ] 1034 1035 def __init__( 1036 self, 1037 account=None, 1038 meta=None, 1039 rate_limit=None, 1040 token=None, 1041 ): 1042 self.account = account if account is not None else None 1043 ''' 1044 The created Account. 1045 ''' 1046 self.meta = meta if meta is not None else None 1047 ''' 1048 Reserved for future use. 1049 ''' 1050 self.rate_limit = rate_limit if rate_limit is not None else None 1051 ''' 1052 Rate limit information. 1053 ''' 1054 self.token = token if token is not None else '' 1055 ''' 1056 The auth token generated for the Account. The Account will use this token to 1057 authenticate with the strongDM API. 1058 ''' 1059 1060 def __repr__(self): 1061 return '<sdm.AccountCreateResponse ' + \ 1062 'account: ' + repr(self.account) + ' ' +\ 1063 'meta: ' + repr(self.meta) + ' ' +\ 1064 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 1065 'token: ' + repr(self.token) + ' ' +\ 1066 '>' 1067 1068 def to_dict(self): 1069 return { 1070 'account': self.account, 1071 'meta': self.meta, 1072 'rate_limit': self.rate_limit, 1073 'token': self.token, 1074 } 1075 1076 @classmethod 1077 def from_dict(cls, d): 1078 return cls( 1079 account=d.get('account'), 1080 meta=d.get('meta'), 1081 rate_limit=d.get('rate_limit'), 1082 token=d.get('token'), 1083 ) 1084 1085 1086class AccountDeleteResponse: 1087 ''' 1088 AccountDeleteResponse returns information about a Account that was deleted. 1089 ''' 1090 __slots__ = [ 1091 'meta', 1092 'rate_limit', 1093 ] 1094 1095 def __init__( 1096 self, 1097 meta=None, 1098 rate_limit=None, 1099 ): 1100 self.meta = meta if meta is not None else None 1101 ''' 1102 Reserved for future use. 1103 ''' 1104 self.rate_limit = rate_limit if rate_limit is not None else None 1105 ''' 1106 Rate limit information. 1107 ''' 1108 1109 def __repr__(self): 1110 return '<sdm.AccountDeleteResponse ' + \ 1111 'meta: ' + repr(self.meta) + ' ' +\ 1112 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 1113 '>' 1114 1115 def to_dict(self): 1116 return { 1117 'meta': self.meta, 1118 'rate_limit': self.rate_limit, 1119 } 1120 1121 @classmethod 1122 def from_dict(cls, d): 1123 return cls( 1124 meta=d.get('meta'), 1125 rate_limit=d.get('rate_limit'), 1126 ) 1127 1128 1129class AccountGetResponse: 1130 ''' 1131 AccountGetResponse returns a requested Account. 1132 ''' 1133 __slots__ = [ 1134 'account', 1135 'meta', 1136 'rate_limit', 1137 ] 1138 1139 def __init__( 1140 self, 1141 account=None, 1142 meta=None, 1143 rate_limit=None, 1144 ): 1145 self.account = account if account is not None else None 1146 ''' 1147 The requested Account. 1148 ''' 1149 self.meta = meta if meta is not None else None 1150 ''' 1151 Reserved for future use. 1152 ''' 1153 self.rate_limit = rate_limit if rate_limit is not None else None 1154 ''' 1155 Rate limit information. 1156 ''' 1157 1158 def __repr__(self): 1159 return '<sdm.AccountGetResponse ' + \ 1160 'account: ' + repr(self.account) + ' ' +\ 1161 'meta: ' + repr(self.meta) + ' ' +\ 1162 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 1163 '>' 1164 1165 def to_dict(self): 1166 return { 1167 'account': self.account, 1168 'meta': self.meta, 1169 'rate_limit': self.rate_limit, 1170 } 1171 1172 @classmethod 1173 def from_dict(cls, d): 1174 return cls( 1175 account=d.get('account'), 1176 meta=d.get('meta'), 1177 rate_limit=d.get('rate_limit'), 1178 ) 1179 1180 1181class AccountGrant: 1182 ''' 1183 AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource. 1184 ''' 1185 __slots__ = [ 1186 'account_id', 1187 'id', 1188 'resource_id', 1189 'start_from', 1190 'valid_until', 1191 ] 1192 1193 def __init__( 1194 self, 1195 account_id=None, 1196 id=None, 1197 resource_id=None, 1198 start_from=None, 1199 valid_until=None, 1200 ): 1201 self.account_id = account_id if account_id is not None else '' 1202 ''' 1203 The id of the attached role of this AccountGrant. 1204 ''' 1205 self.id = id if id is not None else '' 1206 ''' 1207 Unique identifier of the AccountGrant. 1208 ''' 1209 self.resource_id = resource_id if resource_id is not None else '' 1210 ''' 1211 The id of the composite role of this AccountGrant. 1212 ''' 1213 self.start_from = start_from if start_from is not None else None 1214 ''' 1215 The timestamp when the resource will be granted. Optional. Both start_at 1216 and end_at must be defined together, or not defined at all. 1217 ''' 1218 self.valid_until = valid_until if valid_until is not None else None 1219 ''' 1220 The timestamp when the resource grant will expire. Optional. Both 1221 start_at and end_at must be defined together, or not defined at all. 1222 ''' 1223 1224 def __repr__(self): 1225 return '<sdm.AccountGrant ' + \ 1226 'account_id: ' + repr(self.account_id) + ' ' +\ 1227 'id: ' + repr(self.id) + ' ' +\ 1228 'resource_id: ' + repr(self.resource_id) + ' ' +\ 1229 'start_from: ' + repr(self.start_from) + ' ' +\ 1230 'valid_until: ' + repr(self.valid_until) + ' ' +\ 1231 '>' 1232 1233 def to_dict(self): 1234 return { 1235 'account_id': self.account_id, 1236 'id': self.id, 1237 'resource_id': self.resource_id, 1238 'start_from': self.start_from, 1239 'valid_until': self.valid_until, 1240 } 1241 1242 @classmethod 1243 def from_dict(cls, d): 1244 return cls( 1245 account_id=d.get('account_id'), 1246 id=d.get('id'), 1247 resource_id=d.get('resource_id'), 1248 start_from=d.get('start_from'), 1249 valid_until=d.get('valid_until'), 1250 ) 1251 1252 1253class AccountGrantCreateResponse: 1254 ''' 1255 AccountGrantCreateResponse reports how the AccountGrants were created in the system. 1256 ''' 1257 __slots__ = [ 1258 'account_grant', 1259 'meta', 1260 'rate_limit', 1261 ] 1262 1263 def __init__( 1264 self, 1265 account_grant=None, 1266 meta=None, 1267 rate_limit=None, 1268 ): 1269 self.account_grant = account_grant if account_grant is not None else None 1270 ''' 1271 The created AccountGrant. 1272 ''' 1273 self.meta = meta if meta is not None else None 1274 ''' 1275 Reserved for future use. 1276 ''' 1277 self.rate_limit = rate_limit if rate_limit is not None else None 1278 ''' 1279 Rate limit information. 1280 ''' 1281 1282 def __repr__(self): 1283 return '<sdm.AccountGrantCreateResponse ' + \ 1284 'account_grant: ' + repr(self.account_grant) + ' ' +\ 1285 'meta: ' + repr(self.meta) + ' ' +\ 1286 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 1287 '>' 1288 1289 def to_dict(self): 1290 return { 1291 'account_grant': self.account_grant, 1292 'meta': self.meta, 1293 'rate_limit': self.rate_limit, 1294 } 1295 1296 @classmethod 1297 def from_dict(cls, d): 1298 return cls( 1299 account_grant=d.get('account_grant'), 1300 meta=d.get('meta'), 1301 rate_limit=d.get('rate_limit'), 1302 ) 1303 1304 1305class AccountGrantDeleteResponse: 1306 ''' 1307 AccountGrantDeleteResponse returns information about a AccountGrant that was deleted. 1308 ''' 1309 __slots__ = [ 1310 'meta', 1311 'rate_limit', 1312 ] 1313 1314 def __init__( 1315 self, 1316 meta=None, 1317 rate_limit=None, 1318 ): 1319 self.meta = meta if meta is not None else None 1320 ''' 1321 Reserved for future use. 1322 ''' 1323 self.rate_limit = rate_limit if rate_limit is not None else None 1324 ''' 1325 Rate limit information. 1326 ''' 1327 1328 def __repr__(self): 1329 return '<sdm.AccountGrantDeleteResponse ' + \ 1330 'meta: ' + repr(self.meta) + ' ' +\ 1331 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 1332 '>' 1333 1334 def to_dict(self): 1335 return { 1336 'meta': self.meta, 1337 'rate_limit': self.rate_limit, 1338 } 1339 1340 @classmethod 1341 def from_dict(cls, d): 1342 return cls( 1343 meta=d.get('meta'), 1344 rate_limit=d.get('rate_limit'), 1345 ) 1346 1347 1348class AccountGrantGetResponse: 1349 ''' 1350 AccountGrantGetResponse returns a requested AccountGrant. 1351 ''' 1352 __slots__ = [ 1353 'account_grant', 1354 'meta', 1355 'rate_limit', 1356 ] 1357 1358 def __init__( 1359 self, 1360 account_grant=None, 1361 meta=None, 1362 rate_limit=None, 1363 ): 1364 self.account_grant = account_grant if account_grant is not None else None 1365 ''' 1366 The requested AccountGrant. 1367 ''' 1368 self.meta = meta if meta is not None else None 1369 ''' 1370 Reserved for future use. 1371 ''' 1372 self.rate_limit = rate_limit if rate_limit is not None else None 1373 ''' 1374 Rate limit information. 1375 ''' 1376 1377 def __repr__(self): 1378 return '<sdm.AccountGrantGetResponse ' + \ 1379 'account_grant: ' + repr(self.account_grant) + ' ' +\ 1380 'meta: ' + repr(self.meta) + ' ' +\ 1381 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 1382 '>' 1383 1384 def to_dict(self): 1385 return { 1386 'account_grant': self.account_grant, 1387 'meta': self.meta, 1388 'rate_limit': self.rate_limit, 1389 } 1390 1391 @classmethod 1392 def from_dict(cls, d): 1393 return cls( 1394 account_grant=d.get('account_grant'), 1395 meta=d.get('meta'), 1396 rate_limit=d.get('rate_limit'), 1397 ) 1398 1399 1400class AccountUpdateResponse: 1401 ''' 1402 AccountUpdateResponse returns the fields of a Account after it has been updated by 1403 a AccountUpdateRequest. 1404 ''' 1405 __slots__ = [ 1406 'account', 1407 'meta', 1408 'rate_limit', 1409 ] 1410 1411 def __init__( 1412 self, 1413 account=None, 1414 meta=None, 1415 rate_limit=None, 1416 ): 1417 self.account = account if account is not None else None 1418 ''' 1419 The updated Account. 1420 ''' 1421 self.meta = meta if meta is not None else None 1422 ''' 1423 Reserved for future use. 1424 ''' 1425 self.rate_limit = rate_limit if rate_limit is not None else None 1426 ''' 1427 Rate limit information. 1428 ''' 1429 1430 def __repr__(self): 1431 return '<sdm.AccountUpdateResponse ' + \ 1432 'account: ' + repr(self.account) + ' ' +\ 1433 'meta: ' + repr(self.meta) + ' ' +\ 1434 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 1435 '>' 1436 1437 def to_dict(self): 1438 return { 1439 'account': self.account, 1440 'meta': self.meta, 1441 'rate_limit': self.rate_limit, 1442 } 1443 1444 @classmethod 1445 def from_dict(cls, d): 1446 return cls( 1447 account=d.get('account'), 1448 meta=d.get('meta'), 1449 rate_limit=d.get('rate_limit'), 1450 ) 1451 1452 1453class AmazonEKS: 1454 ''' 1455 1456 ''' 1457 __slots__ = [ 1458 'access_key', 1459 'certificate_authority', 1460 'cluster_name', 1461 'egress_filter', 1462 'endpoint', 1463 'healthcheck_namespace', 1464 'healthy', 1465 'id', 1466 'name', 1467 'region', 1468 'role_arn', 1469 'role_external_id', 1470 'secret_access_key', 1471 'secret_store_id', 1472 'tags', 1473 ] 1474 1475 def __init__( 1476 self, 1477 access_key=None, 1478 certificate_authority=None, 1479 cluster_name=None, 1480 egress_filter=None, 1481 endpoint=None, 1482 healthcheck_namespace=None, 1483 healthy=None, 1484 id=None, 1485 name=None, 1486 region=None, 1487 role_arn=None, 1488 role_external_id=None, 1489 secret_access_key=None, 1490 secret_store_id=None, 1491 tags=None, 1492 ): 1493 self.access_key = access_key if access_key is not None else '' 1494 ''' 1495 1496 ''' 1497 self.certificate_authority = certificate_authority if certificate_authority is not None else '' 1498 ''' 1499 1500 ''' 1501 self.cluster_name = cluster_name if cluster_name is not None else '' 1502 ''' 1503 1504 ''' 1505 self.egress_filter = egress_filter if egress_filter is not None else '' 1506 ''' 1507 A filter applied to the routing logic to pin datasource to nodes. 1508 ''' 1509 self.endpoint = endpoint if endpoint is not None else '' 1510 ''' 1511 1512 ''' 1513 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 1514 ''' 1515 The path used to check the health of your connection. Defaults to `default`. 1516 ''' 1517 self.healthy = healthy if healthy is not None else False 1518 ''' 1519 True if the datasource is reachable and the credentials are valid. 1520 ''' 1521 self.id = id if id is not None else '' 1522 ''' 1523 Unique identifier of the Resource. 1524 ''' 1525 self.name = name if name is not None else '' 1526 ''' 1527 Unique human-readable name of the Resource. 1528 ''' 1529 self.region = region if region is not None else '' 1530 ''' 1531 1532 ''' 1533 self.role_arn = role_arn if role_arn is not None else '' 1534 ''' 1535 1536 ''' 1537 self.role_external_id = role_external_id if role_external_id is not None else '' 1538 ''' 1539 1540 ''' 1541 self.secret_access_key = secret_access_key if secret_access_key is not None else '' 1542 ''' 1543 1544 ''' 1545 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 1546 ''' 1547 ID of the secret store containing credentials for this resource, if any. 1548 ''' 1549 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 1550 ''' 1551 Tags is a map of key, value pairs. 1552 ''' 1553 1554 def __repr__(self): 1555 return '<sdm.AmazonEKS ' + \ 1556 'access_key: ' + repr(self.access_key) + ' ' +\ 1557 'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\ 1558 'cluster_name: ' + repr(self.cluster_name) + ' ' +\ 1559 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 1560 'endpoint: ' + repr(self.endpoint) + ' ' +\ 1561 'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\ 1562 'healthy: ' + repr(self.healthy) + ' ' +\ 1563 'id: ' + repr(self.id) + ' ' +\ 1564 'name: ' + repr(self.name) + ' ' +\ 1565 'region: ' + repr(self.region) + ' ' +\ 1566 'role_arn: ' + repr(self.role_arn) + ' ' +\ 1567 'role_external_id: ' + repr(self.role_external_id) + ' ' +\ 1568 'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\ 1569 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 1570 'tags: ' + repr(self.tags) + ' ' +\ 1571 '>' 1572 1573 def to_dict(self): 1574 return { 1575 'access_key': self.access_key, 1576 'certificate_authority': self.certificate_authority, 1577 'cluster_name': self.cluster_name, 1578 'egress_filter': self.egress_filter, 1579 'endpoint': self.endpoint, 1580 'healthcheck_namespace': self.healthcheck_namespace, 1581 'healthy': self.healthy, 1582 'id': self.id, 1583 'name': self.name, 1584 'region': self.region, 1585 'role_arn': self.role_arn, 1586 'role_external_id': self.role_external_id, 1587 'secret_access_key': self.secret_access_key, 1588 'secret_store_id': self.secret_store_id, 1589 'tags': self.tags, 1590 } 1591 1592 @classmethod 1593 def from_dict(cls, d): 1594 return cls( 1595 access_key=d.get('access_key'), 1596 certificate_authority=d.get('certificate_authority'), 1597 cluster_name=d.get('cluster_name'), 1598 egress_filter=d.get('egress_filter'), 1599 endpoint=d.get('endpoint'), 1600 healthcheck_namespace=d.get('healthcheck_namespace'), 1601 healthy=d.get('healthy'), 1602 id=d.get('id'), 1603 name=d.get('name'), 1604 region=d.get('region'), 1605 role_arn=d.get('role_arn'), 1606 role_external_id=d.get('role_external_id'), 1607 secret_access_key=d.get('secret_access_key'), 1608 secret_store_id=d.get('secret_store_id'), 1609 tags=d.get('tags'), 1610 ) 1611 1612 1613class AmazonEKSUserImpersonation: 1614 ''' 1615 1616 ''' 1617 __slots__ = [ 1618 'access_key', 1619 'certificate_authority', 1620 'cluster_name', 1621 'egress_filter', 1622 'endpoint', 1623 'healthcheck_namespace', 1624 'healthy', 1625 'id', 1626 'name', 1627 'region', 1628 'role_arn', 1629 'role_external_id', 1630 'secret_access_key', 1631 'secret_store_id', 1632 'tags', 1633 ] 1634 1635 def __init__( 1636 self, 1637 access_key=None, 1638 certificate_authority=None, 1639 cluster_name=None, 1640 egress_filter=None, 1641 endpoint=None, 1642 healthcheck_namespace=None, 1643 healthy=None, 1644 id=None, 1645 name=None, 1646 region=None, 1647 role_arn=None, 1648 role_external_id=None, 1649 secret_access_key=None, 1650 secret_store_id=None, 1651 tags=None, 1652 ): 1653 self.access_key = access_key if access_key is not None else '' 1654 ''' 1655 1656 ''' 1657 self.certificate_authority = certificate_authority if certificate_authority is not None else '' 1658 ''' 1659 1660 ''' 1661 self.cluster_name = cluster_name if cluster_name is not None else '' 1662 ''' 1663 1664 ''' 1665 self.egress_filter = egress_filter if egress_filter is not None else '' 1666 ''' 1667 A filter applied to the routing logic to pin datasource to nodes. 1668 ''' 1669 self.endpoint = endpoint if endpoint is not None else '' 1670 ''' 1671 1672 ''' 1673 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 1674 ''' 1675 The path used to check the health of your connection. Defaults to `default`. 1676 ''' 1677 self.healthy = healthy if healthy is not None else False 1678 ''' 1679 True if the datasource is reachable and the credentials are valid. 1680 ''' 1681 self.id = id if id is not None else '' 1682 ''' 1683 Unique identifier of the Resource. 1684 ''' 1685 self.name = name if name is not None else '' 1686 ''' 1687 Unique human-readable name of the Resource. 1688 ''' 1689 self.region = region if region is not None else '' 1690 ''' 1691 1692 ''' 1693 self.role_arn = role_arn if role_arn is not None else '' 1694 ''' 1695 1696 ''' 1697 self.role_external_id = role_external_id if role_external_id is not None else '' 1698 ''' 1699 1700 ''' 1701 self.secret_access_key = secret_access_key if secret_access_key is not None else '' 1702 ''' 1703 1704 ''' 1705 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 1706 ''' 1707 ID of the secret store containing credentials for this resource, if any. 1708 ''' 1709 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 1710 ''' 1711 Tags is a map of key, value pairs. 1712 ''' 1713 1714 def __repr__(self): 1715 return '<sdm.AmazonEKSUserImpersonation ' + \ 1716 'access_key: ' + repr(self.access_key) + ' ' +\ 1717 'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\ 1718 'cluster_name: ' + repr(self.cluster_name) + ' ' +\ 1719 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 1720 'endpoint: ' + repr(self.endpoint) + ' ' +\ 1721 'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\ 1722 'healthy: ' + repr(self.healthy) + ' ' +\ 1723 'id: ' + repr(self.id) + ' ' +\ 1724 'name: ' + repr(self.name) + ' ' +\ 1725 'region: ' + repr(self.region) + ' ' +\ 1726 'role_arn: ' + repr(self.role_arn) + ' ' +\ 1727 'role_external_id: ' + repr(self.role_external_id) + ' ' +\ 1728 'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\ 1729 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 1730 'tags: ' + repr(self.tags) + ' ' +\ 1731 '>' 1732 1733 def to_dict(self): 1734 return { 1735 'access_key': self.access_key, 1736 'certificate_authority': self.certificate_authority, 1737 'cluster_name': self.cluster_name, 1738 'egress_filter': self.egress_filter, 1739 'endpoint': self.endpoint, 1740 'healthcheck_namespace': self.healthcheck_namespace, 1741 'healthy': self.healthy, 1742 'id': self.id, 1743 'name': self.name, 1744 'region': self.region, 1745 'role_arn': self.role_arn, 1746 'role_external_id': self.role_external_id, 1747 'secret_access_key': self.secret_access_key, 1748 'secret_store_id': self.secret_store_id, 1749 'tags': self.tags, 1750 } 1751 1752 @classmethod 1753 def from_dict(cls, d): 1754 return cls( 1755 access_key=d.get('access_key'), 1756 certificate_authority=d.get('certificate_authority'), 1757 cluster_name=d.get('cluster_name'), 1758 egress_filter=d.get('egress_filter'), 1759 endpoint=d.get('endpoint'), 1760 healthcheck_namespace=d.get('healthcheck_namespace'), 1761 healthy=d.get('healthy'), 1762 id=d.get('id'), 1763 name=d.get('name'), 1764 region=d.get('region'), 1765 role_arn=d.get('role_arn'), 1766 role_external_id=d.get('role_external_id'), 1767 secret_access_key=d.get('secret_access_key'), 1768 secret_store_id=d.get('secret_store_id'), 1769 tags=d.get('tags'), 1770 ) 1771 1772 1773class AmazonES: 1774 ''' 1775 1776 ''' 1777 __slots__ = [ 1778 'access_key', 1779 'egress_filter', 1780 'endpoint', 1781 'healthy', 1782 'id', 1783 'name', 1784 'port_override', 1785 'region', 1786 'role_arn', 1787 'role_external_id', 1788 'secret_access_key', 1789 'secret_store_id', 1790 'tags', 1791 ] 1792 1793 def __init__( 1794 self, 1795 access_key=None, 1796 egress_filter=None, 1797 endpoint=None, 1798 healthy=None, 1799 id=None, 1800 name=None, 1801 port_override=None, 1802 region=None, 1803 role_arn=None, 1804 role_external_id=None, 1805 secret_access_key=None, 1806 secret_store_id=None, 1807 tags=None, 1808 ): 1809 self.access_key = access_key if access_key is not None else '' 1810 ''' 1811 1812 ''' 1813 self.egress_filter = egress_filter if egress_filter is not None else '' 1814 ''' 1815 A filter applied to the routing logic to pin datasource to nodes. 1816 ''' 1817 self.endpoint = endpoint if endpoint is not None else '' 1818 ''' 1819 1820 ''' 1821 self.healthy = healthy if healthy is not None else False 1822 ''' 1823 True if the datasource is reachable and the credentials are valid. 1824 ''' 1825 self.id = id if id is not None else '' 1826 ''' 1827 Unique identifier of the Resource. 1828 ''' 1829 self.name = name if name is not None else '' 1830 ''' 1831 Unique human-readable name of the Resource. 1832 ''' 1833 self.port_override = port_override if port_override is not None else 0 1834 ''' 1835 1836 ''' 1837 self.region = region if region is not None else '' 1838 ''' 1839 1840 ''' 1841 self.role_arn = role_arn if role_arn is not None else '' 1842 ''' 1843 1844 ''' 1845 self.role_external_id = role_external_id if role_external_id is not None else '' 1846 ''' 1847 1848 ''' 1849 self.secret_access_key = secret_access_key if secret_access_key is not None else '' 1850 ''' 1851 1852 ''' 1853 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 1854 ''' 1855 ID of the secret store containing credentials for this resource, if any. 1856 ''' 1857 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 1858 ''' 1859 Tags is a map of key, value pairs. 1860 ''' 1861 1862 def __repr__(self): 1863 return '<sdm.AmazonES ' + \ 1864 'access_key: ' + repr(self.access_key) + ' ' +\ 1865 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 1866 'endpoint: ' + repr(self.endpoint) + ' ' +\ 1867 'healthy: ' + repr(self.healthy) + ' ' +\ 1868 'id: ' + repr(self.id) + ' ' +\ 1869 'name: ' + repr(self.name) + ' ' +\ 1870 'port_override: ' + repr(self.port_override) + ' ' +\ 1871 'region: ' + repr(self.region) + ' ' +\ 1872 'role_arn: ' + repr(self.role_arn) + ' ' +\ 1873 'role_external_id: ' + repr(self.role_external_id) + ' ' +\ 1874 'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\ 1875 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 1876 'tags: ' + repr(self.tags) + ' ' +\ 1877 '>' 1878 1879 def to_dict(self): 1880 return { 1881 'access_key': self.access_key, 1882 'egress_filter': self.egress_filter, 1883 'endpoint': self.endpoint, 1884 'healthy': self.healthy, 1885 'id': self.id, 1886 'name': self.name, 1887 'port_override': self.port_override, 1888 'region': self.region, 1889 'role_arn': self.role_arn, 1890 'role_external_id': self.role_external_id, 1891 'secret_access_key': self.secret_access_key, 1892 'secret_store_id': self.secret_store_id, 1893 'tags': self.tags, 1894 } 1895 1896 @classmethod 1897 def from_dict(cls, d): 1898 return cls( 1899 access_key=d.get('access_key'), 1900 egress_filter=d.get('egress_filter'), 1901 endpoint=d.get('endpoint'), 1902 healthy=d.get('healthy'), 1903 id=d.get('id'), 1904 name=d.get('name'), 1905 port_override=d.get('port_override'), 1906 region=d.get('region'), 1907 role_arn=d.get('role_arn'), 1908 role_external_id=d.get('role_external_id'), 1909 secret_access_key=d.get('secret_access_key'), 1910 secret_store_id=d.get('secret_store_id'), 1911 tags=d.get('tags'), 1912 ) 1913 1914 1915class AmazonMQAMQP091: 1916 ''' 1917 1918 ''' 1919 __slots__ = [ 1920 'egress_filter', 1921 'healthy', 1922 'hostname', 1923 'id', 1924 'name', 1925 'password', 1926 'port', 1927 'port_override', 1928 'secret_store_id', 1929 'tags', 1930 'tls_required', 1931 'username', 1932 ] 1933 1934 def __init__( 1935 self, 1936 egress_filter=None, 1937 healthy=None, 1938 hostname=None, 1939 id=None, 1940 name=None, 1941 password=None, 1942 port=None, 1943 port_override=None, 1944 secret_store_id=None, 1945 tags=None, 1946 tls_required=None, 1947 username=None, 1948 ): 1949 self.egress_filter = egress_filter if egress_filter is not None else '' 1950 ''' 1951 A filter applied to the routing logic to pin datasource to nodes. 1952 ''' 1953 self.healthy = healthy if healthy is not None else False 1954 ''' 1955 True if the datasource is reachable and the credentials are valid. 1956 ''' 1957 self.hostname = hostname if hostname is not None else '' 1958 ''' 1959 1960 ''' 1961 self.id = id if id is not None else '' 1962 ''' 1963 Unique identifier of the Resource. 1964 ''' 1965 self.name = name if name is not None else '' 1966 ''' 1967 Unique human-readable name of the Resource. 1968 ''' 1969 self.password = password if password is not None else '' 1970 ''' 1971 1972 ''' 1973 self.port = port if port is not None else 0 1974 ''' 1975 1976 ''' 1977 self.port_override = port_override if port_override is not None else 0 1978 ''' 1979 1980 ''' 1981 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 1982 ''' 1983 ID of the secret store containing credentials for this resource, if any. 1984 ''' 1985 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 1986 ''' 1987 Tags is a map of key, value pairs. 1988 ''' 1989 self.tls_required = tls_required if tls_required is not None else False 1990 ''' 1991 1992 ''' 1993 self.username = username if username is not None else '' 1994 ''' 1995 1996 ''' 1997 1998 def __repr__(self): 1999 return '<sdm.AmazonMQAMQP091 ' + \ 2000 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 2001 'healthy: ' + repr(self.healthy) + ' ' +\ 2002 'hostname: ' + repr(self.hostname) + ' ' +\ 2003 'id: ' + repr(self.id) + ' ' +\ 2004 'name: ' + repr(self.name) + ' ' +\ 2005 'password: ' + repr(self.password) + ' ' +\ 2006 'port: ' + repr(self.port) + ' ' +\ 2007 'port_override: ' + repr(self.port_override) + ' ' +\ 2008 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 2009 'tags: ' + repr(self.tags) + ' ' +\ 2010 'tls_required: ' + repr(self.tls_required) + ' ' +\ 2011 'username: ' + repr(self.username) + ' ' +\ 2012 '>' 2013 2014 def to_dict(self): 2015 return { 2016 'egress_filter': self.egress_filter, 2017 'healthy': self.healthy, 2018 'hostname': self.hostname, 2019 'id': self.id, 2020 'name': self.name, 2021 'password': self.password, 2022 'port': self.port, 2023 'port_override': self.port_override, 2024 'secret_store_id': self.secret_store_id, 2025 'tags': self.tags, 2026 'tls_required': self.tls_required, 2027 'username': self.username, 2028 } 2029 2030 @classmethod 2031 def from_dict(cls, d): 2032 return cls( 2033 egress_filter=d.get('egress_filter'), 2034 healthy=d.get('healthy'), 2035 hostname=d.get('hostname'), 2036 id=d.get('id'), 2037 name=d.get('name'), 2038 password=d.get('password'), 2039 port=d.get('port'), 2040 port_override=d.get('port_override'), 2041 secret_store_id=d.get('secret_store_id'), 2042 tags=d.get('tags'), 2043 tls_required=d.get('tls_required'), 2044 username=d.get('username'), 2045 ) 2046 2047 2048class Athena: 2049 ''' 2050 2051 ''' 2052 __slots__ = [ 2053 'access_key', 2054 'egress_filter', 2055 'healthy', 2056 'id', 2057 'name', 2058 'output', 2059 'port_override', 2060 'region', 2061 'role_arn', 2062 'role_external_id', 2063 'secret_access_key', 2064 'secret_store_id', 2065 'tags', 2066 ] 2067 2068 def __init__( 2069 self, 2070 access_key=None, 2071 egress_filter=None, 2072 healthy=None, 2073 id=None, 2074 name=None, 2075 output=None, 2076 port_override=None, 2077 region=None, 2078 role_arn=None, 2079 role_external_id=None, 2080 secret_access_key=None, 2081 secret_store_id=None, 2082 tags=None, 2083 ): 2084 self.access_key = access_key if access_key is not None else '' 2085 ''' 2086 2087 ''' 2088 self.egress_filter = egress_filter if egress_filter is not None else '' 2089 ''' 2090 A filter applied to the routing logic to pin datasource to nodes. 2091 ''' 2092 self.healthy = healthy if healthy is not None else False 2093 ''' 2094 True if the datasource is reachable and the credentials are valid. 2095 ''' 2096 self.id = id if id is not None else '' 2097 ''' 2098 Unique identifier of the Resource. 2099 ''' 2100 self.name = name if name is not None else '' 2101 ''' 2102 Unique human-readable name of the Resource. 2103 ''' 2104 self.output = output if output is not None else '' 2105 ''' 2106 2107 ''' 2108 self.port_override = port_override if port_override is not None else 0 2109 ''' 2110 2111 ''' 2112 self.region = region if region is not None else '' 2113 ''' 2114 2115 ''' 2116 self.role_arn = role_arn if role_arn is not None else '' 2117 ''' 2118 2119 ''' 2120 self.role_external_id = role_external_id if role_external_id is not None else '' 2121 ''' 2122 2123 ''' 2124 self.secret_access_key = secret_access_key if secret_access_key is not None else '' 2125 ''' 2126 2127 ''' 2128 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 2129 ''' 2130 ID of the secret store containing credentials for this resource, if any. 2131 ''' 2132 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 2133 ''' 2134 Tags is a map of key, value pairs. 2135 ''' 2136 2137 def __repr__(self): 2138 return '<sdm.Athena ' + \ 2139 'access_key: ' + repr(self.access_key) + ' ' +\ 2140 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 2141 'healthy: ' + repr(self.healthy) + ' ' +\ 2142 'id: ' + repr(self.id) + ' ' +\ 2143 'name: ' + repr(self.name) + ' ' +\ 2144 'output: ' + repr(self.output) + ' ' +\ 2145 'port_override: ' + repr(self.port_override) + ' ' +\ 2146 'region: ' + repr(self.region) + ' ' +\ 2147 'role_arn: ' + repr(self.role_arn) + ' ' +\ 2148 'role_external_id: ' + repr(self.role_external_id) + ' ' +\ 2149 'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\ 2150 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 2151 'tags: ' + repr(self.tags) + ' ' +\ 2152 '>' 2153 2154 def to_dict(self): 2155 return { 2156 'access_key': self.access_key, 2157 'egress_filter': self.egress_filter, 2158 'healthy': self.healthy, 2159 'id': self.id, 2160 'name': self.name, 2161 'output': self.output, 2162 'port_override': self.port_override, 2163 'region': self.region, 2164 'role_arn': self.role_arn, 2165 'role_external_id': self.role_external_id, 2166 'secret_access_key': self.secret_access_key, 2167 'secret_store_id': self.secret_store_id, 2168 'tags': self.tags, 2169 } 2170 2171 @classmethod 2172 def from_dict(cls, d): 2173 return cls( 2174 access_key=d.get('access_key'), 2175 egress_filter=d.get('egress_filter'), 2176 healthy=d.get('healthy'), 2177 id=d.get('id'), 2178 name=d.get('name'), 2179 output=d.get('output'), 2180 port_override=d.get('port_override'), 2181 region=d.get('region'), 2182 role_arn=d.get('role_arn'), 2183 role_external_id=d.get('role_external_id'), 2184 secret_access_key=d.get('secret_access_key'), 2185 secret_store_id=d.get('secret_store_id'), 2186 tags=d.get('tags'), 2187 ) 2188 2189 2190class AuroraMysql: 2191 ''' 2192 2193 ''' 2194 __slots__ = [ 2195 'database', 2196 'egress_filter', 2197 'healthy', 2198 'hostname', 2199 'id', 2200 'name', 2201 'password', 2202 'port', 2203 'port_override', 2204 'secret_store_id', 2205 'tags', 2206 'username', 2207 ] 2208 2209 def __init__( 2210 self, 2211 database=None, 2212 egress_filter=None, 2213 healthy=None, 2214 hostname=None, 2215 id=None, 2216 name=None, 2217 password=None, 2218 port=None, 2219 port_override=None, 2220 secret_store_id=None, 2221 tags=None, 2222 username=None, 2223 ): 2224 self.database = database if database is not None else '' 2225 ''' 2226 2227 ''' 2228 self.egress_filter = egress_filter if egress_filter is not None else '' 2229 ''' 2230 A filter applied to the routing logic to pin datasource to nodes. 2231 ''' 2232 self.healthy = healthy if healthy is not None else False 2233 ''' 2234 True if the datasource is reachable and the credentials are valid. 2235 ''' 2236 self.hostname = hostname if hostname is not None else '' 2237 ''' 2238 2239 ''' 2240 self.id = id if id is not None else '' 2241 ''' 2242 Unique identifier of the Resource. 2243 ''' 2244 self.name = name if name is not None else '' 2245 ''' 2246 Unique human-readable name of the Resource. 2247 ''' 2248 self.password = password if password is not None else '' 2249 ''' 2250 2251 ''' 2252 self.port = port if port is not None else 0 2253 ''' 2254 2255 ''' 2256 self.port_override = port_override if port_override is not None else 0 2257 ''' 2258 2259 ''' 2260 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 2261 ''' 2262 ID of the secret store containing credentials for this resource, if any. 2263 ''' 2264 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 2265 ''' 2266 Tags is a map of key, value pairs. 2267 ''' 2268 self.username = username if username is not None else '' 2269 ''' 2270 2271 ''' 2272 2273 def __repr__(self): 2274 return '<sdm.AuroraMysql ' + \ 2275 'database: ' + repr(self.database) + ' ' +\ 2276 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 2277 'healthy: ' + repr(self.healthy) + ' ' +\ 2278 'hostname: ' + repr(self.hostname) + ' ' +\ 2279 'id: ' + repr(self.id) + ' ' +\ 2280 'name: ' + repr(self.name) + ' ' +\ 2281 'password: ' + repr(self.password) + ' ' +\ 2282 'port: ' + repr(self.port) + ' ' +\ 2283 'port_override: ' + repr(self.port_override) + ' ' +\ 2284 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 2285 'tags: ' + repr(self.tags) + ' ' +\ 2286 'username: ' + repr(self.username) + ' ' +\ 2287 '>' 2288 2289 def to_dict(self): 2290 return { 2291 'database': self.database, 2292 'egress_filter': self.egress_filter, 2293 'healthy': self.healthy, 2294 'hostname': self.hostname, 2295 'id': self.id, 2296 'name': self.name, 2297 'password': self.password, 2298 'port': self.port, 2299 'port_override': self.port_override, 2300 'secret_store_id': self.secret_store_id, 2301 'tags': self.tags, 2302 'username': self.username, 2303 } 2304 2305 @classmethod 2306 def from_dict(cls, d): 2307 return cls( 2308 database=d.get('database'), 2309 egress_filter=d.get('egress_filter'), 2310 healthy=d.get('healthy'), 2311 hostname=d.get('hostname'), 2312 id=d.get('id'), 2313 name=d.get('name'), 2314 password=d.get('password'), 2315 port=d.get('port'), 2316 port_override=d.get('port_override'), 2317 secret_store_id=d.get('secret_store_id'), 2318 tags=d.get('tags'), 2319 username=d.get('username'), 2320 ) 2321 2322 2323class AuroraPostgres: 2324 ''' 2325 2326 ''' 2327 __slots__ = [ 2328 'database', 2329 'egress_filter', 2330 'healthy', 2331 'hostname', 2332 'id', 2333 'name', 2334 'override_database', 2335 'password', 2336 'port', 2337 'port_override', 2338 'secret_store_id', 2339 'tags', 2340 'username', 2341 ] 2342 2343 def __init__( 2344 self, 2345 database=None, 2346 egress_filter=None, 2347 healthy=None, 2348 hostname=None, 2349 id=None, 2350 name=None, 2351 override_database=None, 2352 password=None, 2353 port=None, 2354 port_override=None, 2355 secret_store_id=None, 2356 tags=None, 2357 username=None, 2358 ): 2359 self.database = database if database is not None else '' 2360 ''' 2361 2362 ''' 2363 self.egress_filter = egress_filter if egress_filter is not None else '' 2364 ''' 2365 A filter applied to the routing logic to pin datasource to nodes. 2366 ''' 2367 self.healthy = healthy if healthy is not None else False 2368 ''' 2369 True if the datasource is reachable and the credentials are valid. 2370 ''' 2371 self.hostname = hostname if hostname is not None else '' 2372 ''' 2373 2374 ''' 2375 self.id = id if id is not None else '' 2376 ''' 2377 Unique identifier of the Resource. 2378 ''' 2379 self.name = name if name is not None else '' 2380 ''' 2381 Unique human-readable name of the Resource. 2382 ''' 2383 self.override_database = override_database if override_database is not None else False 2384 ''' 2385 2386 ''' 2387 self.password = password if password is not None else '' 2388 ''' 2389 2390 ''' 2391 self.port = port if port is not None else 0 2392 ''' 2393 2394 ''' 2395 self.port_override = port_override if port_override is not None else 0 2396 ''' 2397 2398 ''' 2399 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 2400 ''' 2401 ID of the secret store containing credentials for this resource, if any. 2402 ''' 2403 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 2404 ''' 2405 Tags is a map of key, value pairs. 2406 ''' 2407 self.username = username if username is not None else '' 2408 ''' 2409 2410 ''' 2411 2412 def __repr__(self): 2413 return '<sdm.AuroraPostgres ' + \ 2414 'database: ' + repr(self.database) + ' ' +\ 2415 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 2416 'healthy: ' + repr(self.healthy) + ' ' +\ 2417 'hostname: ' + repr(self.hostname) + ' ' +\ 2418 'id: ' + repr(self.id) + ' ' +\ 2419 'name: ' + repr(self.name) + ' ' +\ 2420 'override_database: ' + repr(self.override_database) + ' ' +\ 2421 'password: ' + repr(self.password) + ' ' +\ 2422 'port: ' + repr(self.port) + ' ' +\ 2423 'port_override: ' + repr(self.port_override) + ' ' +\ 2424 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 2425 'tags: ' + repr(self.tags) + ' ' +\ 2426 'username: ' + repr(self.username) + ' ' +\ 2427 '>' 2428 2429 def to_dict(self): 2430 return { 2431 'database': self.database, 2432 'egress_filter': self.egress_filter, 2433 'healthy': self.healthy, 2434 'hostname': self.hostname, 2435 'id': self.id, 2436 'name': self.name, 2437 'override_database': self.override_database, 2438 'password': self.password, 2439 'port': self.port, 2440 'port_override': self.port_override, 2441 'secret_store_id': self.secret_store_id, 2442 'tags': self.tags, 2443 'username': self.username, 2444 } 2445 2446 @classmethod 2447 def from_dict(cls, d): 2448 return cls( 2449 database=d.get('database'), 2450 egress_filter=d.get('egress_filter'), 2451 healthy=d.get('healthy'), 2452 hostname=d.get('hostname'), 2453 id=d.get('id'), 2454 name=d.get('name'), 2455 override_database=d.get('override_database'), 2456 password=d.get('password'), 2457 port=d.get('port'), 2458 port_override=d.get('port_override'), 2459 secret_store_id=d.get('secret_store_id'), 2460 tags=d.get('tags'), 2461 username=d.get('username'), 2462 ) 2463 2464 2465class Azure: 2466 ''' 2467 2468 ''' 2469 __slots__ = [ 2470 'app_id', 2471 'egress_filter', 2472 'healthy', 2473 'id', 2474 'name', 2475 'password', 2476 'secret_store_id', 2477 'tags', 2478 'tenant_id', 2479 ] 2480 2481 def __init__( 2482 self, 2483 app_id=None, 2484 egress_filter=None, 2485 healthy=None, 2486 id=None, 2487 name=None, 2488 password=None, 2489 secret_store_id=None, 2490 tags=None, 2491 tenant_id=None, 2492 ): 2493 self.app_id = app_id if app_id is not None else '' 2494 ''' 2495 2496 ''' 2497 self.egress_filter = egress_filter if egress_filter is not None else '' 2498 ''' 2499 A filter applied to the routing logic to pin datasource to nodes. 2500 ''' 2501 self.healthy = healthy if healthy is not None else False 2502 ''' 2503 True if the datasource is reachable and the credentials are valid. 2504 ''' 2505 self.id = id if id is not None else '' 2506 ''' 2507 Unique identifier of the Resource. 2508 ''' 2509 self.name = name if name is not None else '' 2510 ''' 2511 Unique human-readable name of the Resource. 2512 ''' 2513 self.password = password if password is not None else '' 2514 ''' 2515 2516 ''' 2517 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 2518 ''' 2519 ID of the secret store containing credentials for this resource, if any. 2520 ''' 2521 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 2522 ''' 2523 Tags is a map of key, value pairs. 2524 ''' 2525 self.tenant_id = tenant_id if tenant_id is not None else '' 2526 ''' 2527 2528 ''' 2529 2530 def __repr__(self): 2531 return '<sdm.Azure ' + \ 2532 'app_id: ' + repr(self.app_id) + ' ' +\ 2533 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 2534 'healthy: ' + repr(self.healthy) + ' ' +\ 2535 'id: ' + repr(self.id) + ' ' +\ 2536 'name: ' + repr(self.name) + ' ' +\ 2537 'password: ' + repr(self.password) + ' ' +\ 2538 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 2539 'tags: ' + repr(self.tags) + ' ' +\ 2540 'tenant_id: ' + repr(self.tenant_id) + ' ' +\ 2541 '>' 2542 2543 def to_dict(self): 2544 return { 2545 'app_id': self.app_id, 2546 'egress_filter': self.egress_filter, 2547 'healthy': self.healthy, 2548 'id': self.id, 2549 'name': self.name, 2550 'password': self.password, 2551 'secret_store_id': self.secret_store_id, 2552 'tags': self.tags, 2553 'tenant_id': self.tenant_id, 2554 } 2555 2556 @classmethod 2557 def from_dict(cls, d): 2558 return cls( 2559 app_id=d.get('app_id'), 2560 egress_filter=d.get('egress_filter'), 2561 healthy=d.get('healthy'), 2562 id=d.get('id'), 2563 name=d.get('name'), 2564 password=d.get('password'), 2565 secret_store_id=d.get('secret_store_id'), 2566 tags=d.get('tags'), 2567 tenant_id=d.get('tenant_id'), 2568 ) 2569 2570 2571class AzureCertificate: 2572 ''' 2573 2574 ''' 2575 __slots__ = [ 2576 'app_id', 2577 'client_certificate', 2578 'egress_filter', 2579 'healthy', 2580 'id', 2581 'name', 2582 'secret_store_id', 2583 'tags', 2584 'tenant_id', 2585 ] 2586 2587 def __init__( 2588 self, 2589 app_id=None, 2590 client_certificate=None, 2591 egress_filter=None, 2592 healthy=None, 2593 id=None, 2594 name=None, 2595 secret_store_id=None, 2596 tags=None, 2597 tenant_id=None, 2598 ): 2599 self.app_id = app_id if app_id is not None else '' 2600 ''' 2601 2602 ''' 2603 self.client_certificate = client_certificate if client_certificate is not None else '' 2604 ''' 2605 2606 ''' 2607 self.egress_filter = egress_filter if egress_filter is not None else '' 2608 ''' 2609 A filter applied to the routing logic to pin datasource to nodes. 2610 ''' 2611 self.healthy = healthy if healthy is not None else False 2612 ''' 2613 True if the datasource is reachable and the credentials are valid. 2614 ''' 2615 self.id = id if id is not None else '' 2616 ''' 2617 Unique identifier of the Resource. 2618 ''' 2619 self.name = name if name is not None else '' 2620 ''' 2621 Unique human-readable name of the Resource. 2622 ''' 2623 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 2624 ''' 2625 ID of the secret store containing credentials for this resource, if any. 2626 ''' 2627 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 2628 ''' 2629 Tags is a map of key, value pairs. 2630 ''' 2631 self.tenant_id = tenant_id if tenant_id is not None else '' 2632 ''' 2633 2634 ''' 2635 2636 def __repr__(self): 2637 return '<sdm.AzureCertificate ' + \ 2638 'app_id: ' + repr(self.app_id) + ' ' +\ 2639 'client_certificate: ' + repr(self.client_certificate) + ' ' +\ 2640 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 2641 'healthy: ' + repr(self.healthy) + ' ' +\ 2642 'id: ' + repr(self.id) + ' ' +\ 2643 'name: ' + repr(self.name) + ' ' +\ 2644 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 2645 'tags: ' + repr(self.tags) + ' ' +\ 2646 'tenant_id: ' + repr(self.tenant_id) + ' ' +\ 2647 '>' 2648 2649 def to_dict(self): 2650 return { 2651 'app_id': self.app_id, 2652 'client_certificate': self.client_certificate, 2653 'egress_filter': self.egress_filter, 2654 'healthy': self.healthy, 2655 'id': self.id, 2656 'name': self.name, 2657 'secret_store_id': self.secret_store_id, 2658 'tags': self.tags, 2659 'tenant_id': self.tenant_id, 2660 } 2661 2662 @classmethod 2663 def from_dict(cls, d): 2664 return cls( 2665 app_id=d.get('app_id'), 2666 client_certificate=d.get('client_certificate'), 2667 egress_filter=d.get('egress_filter'), 2668 healthy=d.get('healthy'), 2669 id=d.get('id'), 2670 name=d.get('name'), 2671 secret_store_id=d.get('secret_store_id'), 2672 tags=d.get('tags'), 2673 tenant_id=d.get('tenant_id'), 2674 ) 2675 2676 2677class AzurePostgres: 2678 ''' 2679 2680 ''' 2681 __slots__ = [ 2682 'database', 2683 'egress_filter', 2684 'healthy', 2685 'hostname', 2686 'id', 2687 'name', 2688 'override_database', 2689 'password', 2690 'port', 2691 'port_override', 2692 'secret_store_id', 2693 'tags', 2694 'username', 2695 ] 2696 2697 def __init__( 2698 self, 2699 database=None, 2700 egress_filter=None, 2701 healthy=None, 2702 hostname=None, 2703 id=None, 2704 name=None, 2705 override_database=None, 2706 password=None, 2707 port=None, 2708 port_override=None, 2709 secret_store_id=None, 2710 tags=None, 2711 username=None, 2712 ): 2713 self.database = database if database is not None else '' 2714 ''' 2715 2716 ''' 2717 self.egress_filter = egress_filter if egress_filter is not None else '' 2718 ''' 2719 A filter applied to the routing logic to pin datasource to nodes. 2720 ''' 2721 self.healthy = healthy if healthy is not None else False 2722 ''' 2723 True if the datasource is reachable and the credentials are valid. 2724 ''' 2725 self.hostname = hostname if hostname is not None else '' 2726 ''' 2727 2728 ''' 2729 self.id = id if id is not None else '' 2730 ''' 2731 Unique identifier of the Resource. 2732 ''' 2733 self.name = name if name is not None else '' 2734 ''' 2735 Unique human-readable name of the Resource. 2736 ''' 2737 self.override_database = override_database if override_database is not None else False 2738 ''' 2739 2740 ''' 2741 self.password = password if password is not None else '' 2742 ''' 2743 2744 ''' 2745 self.port = port if port is not None else 0 2746 ''' 2747 2748 ''' 2749 self.port_override = port_override if port_override is not None else 0 2750 ''' 2751 2752 ''' 2753 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 2754 ''' 2755 ID of the secret store containing credentials for this resource, if any. 2756 ''' 2757 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 2758 ''' 2759 Tags is a map of key, value pairs. 2760 ''' 2761 self.username = username if username is not None else '' 2762 ''' 2763 2764 ''' 2765 2766 def __repr__(self): 2767 return '<sdm.AzurePostgres ' + \ 2768 'database: ' + repr(self.database) + ' ' +\ 2769 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 2770 'healthy: ' + repr(self.healthy) + ' ' +\ 2771 'hostname: ' + repr(self.hostname) + ' ' +\ 2772 'id: ' + repr(self.id) + ' ' +\ 2773 'name: ' + repr(self.name) + ' ' +\ 2774 'override_database: ' + repr(self.override_database) + ' ' +\ 2775 'password: ' + repr(self.password) + ' ' +\ 2776 'port: ' + repr(self.port) + ' ' +\ 2777 'port_override: ' + repr(self.port_override) + ' ' +\ 2778 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 2779 'tags: ' + repr(self.tags) + ' ' +\ 2780 'username: ' + repr(self.username) + ' ' +\ 2781 '>' 2782 2783 def to_dict(self): 2784 return { 2785 'database': self.database, 2786 'egress_filter': self.egress_filter, 2787 'healthy': self.healthy, 2788 'hostname': self.hostname, 2789 'id': self.id, 2790 'name': self.name, 2791 'override_database': self.override_database, 2792 'password': self.password, 2793 'port': self.port, 2794 'port_override': self.port_override, 2795 'secret_store_id': self.secret_store_id, 2796 'tags': self.tags, 2797 'username': self.username, 2798 } 2799 2800 @classmethod 2801 def from_dict(cls, d): 2802 return cls( 2803 database=d.get('database'), 2804 egress_filter=d.get('egress_filter'), 2805 healthy=d.get('healthy'), 2806 hostname=d.get('hostname'), 2807 id=d.get('id'), 2808 name=d.get('name'), 2809 override_database=d.get('override_database'), 2810 password=d.get('password'), 2811 port=d.get('port'), 2812 port_override=d.get('port_override'), 2813 secret_store_id=d.get('secret_store_id'), 2814 tags=d.get('tags'), 2815 username=d.get('username'), 2816 ) 2817 2818 2819class AzureStore: 2820 ''' 2821 2822 ''' 2823 __slots__ = [ 2824 'id', 2825 'name', 2826 'tags', 2827 'vault_uri', 2828 ] 2829 2830 def __init__( 2831 self, 2832 id=None, 2833 name=None, 2834 tags=None, 2835 vault_uri=None, 2836 ): 2837 self.id = id if id is not None else '' 2838 ''' 2839 Unique identifier of the SecretStore. 2840 ''' 2841 self.name = name if name is not None else '' 2842 ''' 2843 Unique human-readable name of the SecretStore. 2844 ''' 2845 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 2846 ''' 2847 Tags is a map of key, value pairs. 2848 ''' 2849 self.vault_uri = vault_uri if vault_uri is not None else '' 2850 ''' 2851 2852 ''' 2853 2854 def __repr__(self): 2855 return '<sdm.AzureStore ' + \ 2856 'id: ' + repr(self.id) + ' ' +\ 2857 'name: ' + repr(self.name) + ' ' +\ 2858 'tags: ' + repr(self.tags) + ' ' +\ 2859 'vault_uri: ' + repr(self.vault_uri) + ' ' +\ 2860 '>' 2861 2862 def to_dict(self): 2863 return { 2864 'id': self.id, 2865 'name': self.name, 2866 'tags': self.tags, 2867 'vault_uri': self.vault_uri, 2868 } 2869 2870 @classmethod 2871 def from_dict(cls, d): 2872 return cls( 2873 id=d.get('id'), 2874 name=d.get('name'), 2875 tags=d.get('tags'), 2876 vault_uri=d.get('vault_uri'), 2877 ) 2878 2879 2880class BigQuery: 2881 ''' 2882 2883 ''' 2884 __slots__ = [ 2885 'egress_filter', 2886 'endpoint', 2887 'healthy', 2888 'id', 2889 'name', 2890 'port_override', 2891 'private_key', 2892 'project', 2893 'secret_store_id', 2894 'tags', 2895 'username', 2896 ] 2897 2898 def __init__( 2899 self, 2900 egress_filter=None, 2901 endpoint=None, 2902 healthy=None, 2903 id=None, 2904 name=None, 2905 port_override=None, 2906 private_key=None, 2907 project=None, 2908 secret_store_id=None, 2909 tags=None, 2910 username=None, 2911 ): 2912 self.egress_filter = egress_filter if egress_filter is not None else '' 2913 ''' 2914 A filter applied to the routing logic to pin datasource to nodes. 2915 ''' 2916 self.endpoint = endpoint if endpoint is not None else '' 2917 ''' 2918 2919 ''' 2920 self.healthy = healthy if healthy is not None else False 2921 ''' 2922 True if the datasource is reachable and the credentials are valid. 2923 ''' 2924 self.id = id if id is not None else '' 2925 ''' 2926 Unique identifier of the Resource. 2927 ''' 2928 self.name = name if name is not None else '' 2929 ''' 2930 Unique human-readable name of the Resource. 2931 ''' 2932 self.port_override = port_override if port_override is not None else 0 2933 ''' 2934 2935 ''' 2936 self.private_key = private_key if private_key is not None else '' 2937 ''' 2938 2939 ''' 2940 self.project = project if project is not None else '' 2941 ''' 2942 2943 ''' 2944 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 2945 ''' 2946 ID of the secret store containing credentials for this resource, if any. 2947 ''' 2948 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 2949 ''' 2950 Tags is a map of key, value pairs. 2951 ''' 2952 self.username = username if username is not None else '' 2953 ''' 2954 2955 ''' 2956 2957 def __repr__(self): 2958 return '<sdm.BigQuery ' + \ 2959 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 2960 'endpoint: ' + repr(self.endpoint) + ' ' +\ 2961 'healthy: ' + repr(self.healthy) + ' ' +\ 2962 'id: ' + repr(self.id) + ' ' +\ 2963 'name: ' + repr(self.name) + ' ' +\ 2964 'port_override: ' + repr(self.port_override) + ' ' +\ 2965 'private_key: ' + repr(self.private_key) + ' ' +\ 2966 'project: ' + repr(self.project) + ' ' +\ 2967 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 2968 'tags: ' + repr(self.tags) + ' ' +\ 2969 'username: ' + repr(self.username) + ' ' +\ 2970 '>' 2971 2972 def to_dict(self): 2973 return { 2974 'egress_filter': self.egress_filter, 2975 'endpoint': self.endpoint, 2976 'healthy': self.healthy, 2977 'id': self.id, 2978 'name': self.name, 2979 'port_override': self.port_override, 2980 'private_key': self.private_key, 2981 'project': self.project, 2982 'secret_store_id': self.secret_store_id, 2983 'tags': self.tags, 2984 'username': self.username, 2985 } 2986 2987 @classmethod 2988 def from_dict(cls, d): 2989 return cls( 2990 egress_filter=d.get('egress_filter'), 2991 endpoint=d.get('endpoint'), 2992 healthy=d.get('healthy'), 2993 id=d.get('id'), 2994 name=d.get('name'), 2995 port_override=d.get('port_override'), 2996 private_key=d.get('private_key'), 2997 project=d.get('project'), 2998 secret_store_id=d.get('secret_store_id'), 2999 tags=d.get('tags'), 3000 username=d.get('username'), 3001 ) 3002 3003 3004class Cassandra: 3005 ''' 3006 3007 ''' 3008 __slots__ = [ 3009 'egress_filter', 3010 'healthy', 3011 'hostname', 3012 'id', 3013 'name', 3014 'password', 3015 'port', 3016 'port_override', 3017 'secret_store_id', 3018 'tags', 3019 'tls_required', 3020 'username', 3021 ] 3022 3023 def __init__( 3024 self, 3025 egress_filter=None, 3026 healthy=None, 3027 hostname=None, 3028 id=None, 3029 name=None, 3030 password=None, 3031 port=None, 3032 port_override=None, 3033 secret_store_id=None, 3034 tags=None, 3035 tls_required=None, 3036 username=None, 3037 ): 3038 self.egress_filter = egress_filter if egress_filter is not None else '' 3039 ''' 3040 A filter applied to the routing logic to pin datasource to nodes. 3041 ''' 3042 self.healthy = healthy if healthy is not None else False 3043 ''' 3044 True if the datasource is reachable and the credentials are valid. 3045 ''' 3046 self.hostname = hostname if hostname is not None else '' 3047 ''' 3048 3049 ''' 3050 self.id = id if id is not None else '' 3051 ''' 3052 Unique identifier of the Resource. 3053 ''' 3054 self.name = name if name is not None else '' 3055 ''' 3056 Unique human-readable name of the Resource. 3057 ''' 3058 self.password = password if password is not None else '' 3059 ''' 3060 3061 ''' 3062 self.port = port if port is not None else 0 3063 ''' 3064 3065 ''' 3066 self.port_override = port_override if port_override is not None else 0 3067 ''' 3068 3069 ''' 3070 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 3071 ''' 3072 ID of the secret store containing credentials for this resource, if any. 3073 ''' 3074 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 3075 ''' 3076 Tags is a map of key, value pairs. 3077 ''' 3078 self.tls_required = tls_required if tls_required is not None else False 3079 ''' 3080 3081 ''' 3082 self.username = username if username is not None else '' 3083 ''' 3084 3085 ''' 3086 3087 def __repr__(self): 3088 return '<sdm.Cassandra ' + \ 3089 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 3090 'healthy: ' + repr(self.healthy) + ' ' +\ 3091 'hostname: ' + repr(self.hostname) + ' ' +\ 3092 'id: ' + repr(self.id) + ' ' +\ 3093 'name: ' + repr(self.name) + ' ' +\ 3094 'password: ' + repr(self.password) + ' ' +\ 3095 'port: ' + repr(self.port) + ' ' +\ 3096 'port_override: ' + repr(self.port_override) + ' ' +\ 3097 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 3098 'tags: ' + repr(self.tags) + ' ' +\ 3099 'tls_required: ' + repr(self.tls_required) + ' ' +\ 3100 'username: ' + repr(self.username) + ' ' +\ 3101 '>' 3102 3103 def to_dict(self): 3104 return { 3105 'egress_filter': self.egress_filter, 3106 'healthy': self.healthy, 3107 'hostname': self.hostname, 3108 'id': self.id, 3109 'name': self.name, 3110 'password': self.password, 3111 'port': self.port, 3112 'port_override': self.port_override, 3113 'secret_store_id': self.secret_store_id, 3114 'tags': self.tags, 3115 'tls_required': self.tls_required, 3116 'username': self.username, 3117 } 3118 3119 @classmethod 3120 def from_dict(cls, d): 3121 return cls( 3122 egress_filter=d.get('egress_filter'), 3123 healthy=d.get('healthy'), 3124 hostname=d.get('hostname'), 3125 id=d.get('id'), 3126 name=d.get('name'), 3127 password=d.get('password'), 3128 port=d.get('port'), 3129 port_override=d.get('port_override'), 3130 secret_store_id=d.get('secret_store_id'), 3131 tags=d.get('tags'), 3132 tls_required=d.get('tls_required'), 3133 username=d.get('username'), 3134 ) 3135 3136 3137class Citus: 3138 ''' 3139 3140 ''' 3141 __slots__ = [ 3142 'database', 3143 'egress_filter', 3144 'healthy', 3145 'hostname', 3146 'id', 3147 'name', 3148 'override_database', 3149 'password', 3150 'port', 3151 'port_override', 3152 'secret_store_id', 3153 'tags', 3154 'username', 3155 ] 3156 3157 def __init__( 3158 self, 3159 database=None, 3160 egress_filter=None, 3161 healthy=None, 3162 hostname=None, 3163 id=None, 3164 name=None, 3165 override_database=None, 3166 password=None, 3167 port=None, 3168 port_override=None, 3169 secret_store_id=None, 3170 tags=None, 3171 username=None, 3172 ): 3173 self.database = database if database is not None else '' 3174 ''' 3175 3176 ''' 3177 self.egress_filter = egress_filter if egress_filter is not None else '' 3178 ''' 3179 A filter applied to the routing logic to pin datasource to nodes. 3180 ''' 3181 self.healthy = healthy if healthy is not None else False 3182 ''' 3183 True if the datasource is reachable and the credentials are valid. 3184 ''' 3185 self.hostname = hostname if hostname is not None else '' 3186 ''' 3187 3188 ''' 3189 self.id = id if id is not None else '' 3190 ''' 3191 Unique identifier of the Resource. 3192 ''' 3193 self.name = name if name is not None else '' 3194 ''' 3195 Unique human-readable name of the Resource. 3196 ''' 3197 self.override_database = override_database if override_database is not None else False 3198 ''' 3199 3200 ''' 3201 self.password = password if password is not None else '' 3202 ''' 3203 3204 ''' 3205 self.port = port if port is not None else 0 3206 ''' 3207 3208 ''' 3209 self.port_override = port_override if port_override is not None else 0 3210 ''' 3211 3212 ''' 3213 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 3214 ''' 3215 ID of the secret store containing credentials for this resource, if any. 3216 ''' 3217 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 3218 ''' 3219 Tags is a map of key, value pairs. 3220 ''' 3221 self.username = username if username is not None else '' 3222 ''' 3223 3224 ''' 3225 3226 def __repr__(self): 3227 return '<sdm.Citus ' + \ 3228 'database: ' + repr(self.database) + ' ' +\ 3229 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 3230 'healthy: ' + repr(self.healthy) + ' ' +\ 3231 'hostname: ' + repr(self.hostname) + ' ' +\ 3232 'id: ' + repr(self.id) + ' ' +\ 3233 'name: ' + repr(self.name) + ' ' +\ 3234 'override_database: ' + repr(self.override_database) + ' ' +\ 3235 'password: ' + repr(self.password) + ' ' +\ 3236 'port: ' + repr(self.port) + ' ' +\ 3237 'port_override: ' + repr(self.port_override) + ' ' +\ 3238 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 3239 'tags: ' + repr(self.tags) + ' ' +\ 3240 'username: ' + repr(self.username) + ' ' +\ 3241 '>' 3242 3243 def to_dict(self): 3244 return { 3245 'database': self.database, 3246 'egress_filter': self.egress_filter, 3247 'healthy': self.healthy, 3248 'hostname': self.hostname, 3249 'id': self.id, 3250 'name': self.name, 3251 'override_database': self.override_database, 3252 'password': self.password, 3253 'port': self.port, 3254 'port_override': self.port_override, 3255 'secret_store_id': self.secret_store_id, 3256 'tags': self.tags, 3257 'username': self.username, 3258 } 3259 3260 @classmethod 3261 def from_dict(cls, d): 3262 return cls( 3263 database=d.get('database'), 3264 egress_filter=d.get('egress_filter'), 3265 healthy=d.get('healthy'), 3266 hostname=d.get('hostname'), 3267 id=d.get('id'), 3268 name=d.get('name'), 3269 override_database=d.get('override_database'), 3270 password=d.get('password'), 3271 port=d.get('port'), 3272 port_override=d.get('port_override'), 3273 secret_store_id=d.get('secret_store_id'), 3274 tags=d.get('tags'), 3275 username=d.get('username'), 3276 ) 3277 3278 3279class Clustrix: 3280 ''' 3281 3282 ''' 3283 __slots__ = [ 3284 'database', 3285 'egress_filter', 3286 'healthy', 3287 'hostname', 3288 'id', 3289 'name', 3290 'password', 3291 'port', 3292 'port_override', 3293 'secret_store_id', 3294 'tags', 3295 'username', 3296 ] 3297 3298 def __init__( 3299 self, 3300 database=None, 3301 egress_filter=None, 3302 healthy=None, 3303 hostname=None, 3304 id=None, 3305 name=None, 3306 password=None, 3307 port=None, 3308 port_override=None, 3309 secret_store_id=None, 3310 tags=None, 3311 username=None, 3312 ): 3313 self.database = database if database is not None else '' 3314 ''' 3315 3316 ''' 3317 self.egress_filter = egress_filter if egress_filter is not None else '' 3318 ''' 3319 A filter applied to the routing logic to pin datasource to nodes. 3320 ''' 3321 self.healthy = healthy if healthy is not None else False 3322 ''' 3323 True if the datasource is reachable and the credentials are valid. 3324 ''' 3325 self.hostname = hostname if hostname is not None else '' 3326 ''' 3327 3328 ''' 3329 self.id = id if id is not None else '' 3330 ''' 3331 Unique identifier of the Resource. 3332 ''' 3333 self.name = name if name is not None else '' 3334 ''' 3335 Unique human-readable name of the Resource. 3336 ''' 3337 self.password = password if password is not None else '' 3338 ''' 3339 3340 ''' 3341 self.port = port if port is not None else 0 3342 ''' 3343 3344 ''' 3345 self.port_override = port_override if port_override is not None else 0 3346 ''' 3347 3348 ''' 3349 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 3350 ''' 3351 ID of the secret store containing credentials for this resource, if any. 3352 ''' 3353 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 3354 ''' 3355 Tags is a map of key, value pairs. 3356 ''' 3357 self.username = username if username is not None else '' 3358 ''' 3359 3360 ''' 3361 3362 def __repr__(self): 3363 return '<sdm.Clustrix ' + \ 3364 'database: ' + repr(self.database) + ' ' +\ 3365 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 3366 'healthy: ' + repr(self.healthy) + ' ' +\ 3367 'hostname: ' + repr(self.hostname) + ' ' +\ 3368 'id: ' + repr(self.id) + ' ' +\ 3369 'name: ' + repr(self.name) + ' ' +\ 3370 'password: ' + repr(self.password) + ' ' +\ 3371 'port: ' + repr(self.port) + ' ' +\ 3372 'port_override: ' + repr(self.port_override) + ' ' +\ 3373 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 3374 'tags: ' + repr(self.tags) + ' ' +\ 3375 'username: ' + repr(self.username) + ' ' +\ 3376 '>' 3377 3378 def to_dict(self): 3379 return { 3380 'database': self.database, 3381 'egress_filter': self.egress_filter, 3382 'healthy': self.healthy, 3383 'hostname': self.hostname, 3384 'id': self.id, 3385 'name': self.name, 3386 'password': self.password, 3387 'port': self.port, 3388 'port_override': self.port_override, 3389 'secret_store_id': self.secret_store_id, 3390 'tags': self.tags, 3391 'username': self.username, 3392 } 3393 3394 @classmethod 3395 def from_dict(cls, d): 3396 return cls( 3397 database=d.get('database'), 3398 egress_filter=d.get('egress_filter'), 3399 healthy=d.get('healthy'), 3400 hostname=d.get('hostname'), 3401 id=d.get('id'), 3402 name=d.get('name'), 3403 password=d.get('password'), 3404 port=d.get('port'), 3405 port_override=d.get('port_override'), 3406 secret_store_id=d.get('secret_store_id'), 3407 tags=d.get('tags'), 3408 username=d.get('username'), 3409 ) 3410 3411 3412class Cockroach: 3413 ''' 3414 3415 ''' 3416 __slots__ = [ 3417 'database', 3418 'egress_filter', 3419 'healthy', 3420 'hostname', 3421 'id', 3422 'name', 3423 'override_database', 3424 'password', 3425 'port', 3426 'port_override', 3427 'secret_store_id', 3428 'tags', 3429 'username', 3430 ] 3431 3432 def __init__( 3433 self, 3434 database=None, 3435 egress_filter=None, 3436 healthy=None, 3437 hostname=None, 3438 id=None, 3439 name=None, 3440 override_database=None, 3441 password=None, 3442 port=None, 3443 port_override=None, 3444 secret_store_id=None, 3445 tags=None, 3446 username=None, 3447 ): 3448 self.database = database if database is not None else '' 3449 ''' 3450 3451 ''' 3452 self.egress_filter = egress_filter if egress_filter is not None else '' 3453 ''' 3454 A filter applied to the routing logic to pin datasource to nodes. 3455 ''' 3456 self.healthy = healthy if healthy is not None else False 3457 ''' 3458 True if the datasource is reachable and the credentials are valid. 3459 ''' 3460 self.hostname = hostname if hostname is not None else '' 3461 ''' 3462 3463 ''' 3464 self.id = id if id is not None else '' 3465 ''' 3466 Unique identifier of the Resource. 3467 ''' 3468 self.name = name if name is not None else '' 3469 ''' 3470 Unique human-readable name of the Resource. 3471 ''' 3472 self.override_database = override_database if override_database is not None else False 3473 ''' 3474 3475 ''' 3476 self.password = password if password is not None else '' 3477 ''' 3478 3479 ''' 3480 self.port = port if port is not None else 0 3481 ''' 3482 3483 ''' 3484 self.port_override = port_override if port_override is not None else 0 3485 ''' 3486 3487 ''' 3488 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 3489 ''' 3490 ID of the secret store containing credentials for this resource, if any. 3491 ''' 3492 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 3493 ''' 3494 Tags is a map of key, value pairs. 3495 ''' 3496 self.username = username if username is not None else '' 3497 ''' 3498 3499 ''' 3500 3501 def __repr__(self): 3502 return '<sdm.Cockroach ' + \ 3503 'database: ' + repr(self.database) + ' ' +\ 3504 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 3505 'healthy: ' + repr(self.healthy) + ' ' +\ 3506 'hostname: ' + repr(self.hostname) + ' ' +\ 3507 'id: ' + repr(self.id) + ' ' +\ 3508 'name: ' + repr(self.name) + ' ' +\ 3509 'override_database: ' + repr(self.override_database) + ' ' +\ 3510 'password: ' + repr(self.password) + ' ' +\ 3511 'port: ' + repr(self.port) + ' ' +\ 3512 'port_override: ' + repr(self.port_override) + ' ' +\ 3513 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 3514 'tags: ' + repr(self.tags) + ' ' +\ 3515 'username: ' + repr(self.username) + ' ' +\ 3516 '>' 3517 3518 def to_dict(self): 3519 return { 3520 'database': self.database, 3521 'egress_filter': self.egress_filter, 3522 'healthy': self.healthy, 3523 'hostname': self.hostname, 3524 'id': self.id, 3525 'name': self.name, 3526 'override_database': self.override_database, 3527 'password': self.password, 3528 'port': self.port, 3529 'port_override': self.port_override, 3530 'secret_store_id': self.secret_store_id, 3531 'tags': self.tags, 3532 'username': self.username, 3533 } 3534 3535 @classmethod 3536 def from_dict(cls, d): 3537 return cls( 3538 database=d.get('database'), 3539 egress_filter=d.get('egress_filter'), 3540 healthy=d.get('healthy'), 3541 hostname=d.get('hostname'), 3542 id=d.get('id'), 3543 name=d.get('name'), 3544 override_database=d.get('override_database'), 3545 password=d.get('password'), 3546 port=d.get('port'), 3547 port_override=d.get('port_override'), 3548 secret_store_id=d.get('secret_store_id'), 3549 tags=d.get('tags'), 3550 username=d.get('username'), 3551 ) 3552 3553 3554class ControlPanelGetSSHCAPublicKeyResponse: 3555 ''' 3556 ControlPanelGetSSHCAPublicKeyResponse represents a request for an 3557 organization's SSH Certificate Authority public key. 3558 ''' 3559 __slots__ = [ 3560 'meta', 3561 'public_key', 3562 'rate_limit', 3563 ] 3564 3565 def __init__( 3566 self, 3567 meta=None, 3568 public_key=None, 3569 rate_limit=None, 3570 ): 3571 self.meta = meta if meta is not None else None 3572 ''' 3573 Reserved for future use. 3574 ''' 3575 self.public_key = public_key if public_key is not None else '' 3576 ''' 3577 The public key of the SSH Certificate Authority, in OpenSSH RSA public 3578 key format. 3579 ''' 3580 self.rate_limit = rate_limit if rate_limit is not None else None 3581 ''' 3582 Rate limit information. 3583 ''' 3584 3585 def __repr__(self): 3586 return '<sdm.ControlPanelGetSSHCAPublicKeyResponse ' + \ 3587 'meta: ' + repr(self.meta) + ' ' +\ 3588 'public_key: ' + repr(self.public_key) + ' ' +\ 3589 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 3590 '>' 3591 3592 def to_dict(self): 3593 return { 3594 'meta': self.meta, 3595 'public_key': self.public_key, 3596 'rate_limit': self.rate_limit, 3597 } 3598 3599 @classmethod 3600 def from_dict(cls, d): 3601 return cls( 3602 meta=d.get('meta'), 3603 public_key=d.get('public_key'), 3604 rate_limit=d.get('rate_limit'), 3605 ) 3606 3607 3608class ControlPanelVerifyJWTResponse: 3609 ''' 3610 ControlPanelVerifyJWTResponse reports whether x-sdm-token is valid. 3611 ''' 3612 __slots__ = [ 3613 'meta', 3614 'rate_limit', 3615 'valid', 3616 ] 3617 3618 def __init__( 3619 self, 3620 meta=None, 3621 rate_limit=None, 3622 valid=None, 3623 ): 3624 self.meta = meta if meta is not None else None 3625 ''' 3626 Reserved for future use. 3627 ''' 3628 self.rate_limit = rate_limit if rate_limit is not None else None 3629 ''' 3630 Rate limit information. 3631 ''' 3632 self.valid = valid if valid is not None else False 3633 ''' 3634 Reports if the given token is valid. 3635 ''' 3636 3637 def __repr__(self): 3638 return '<sdm.ControlPanelVerifyJWTResponse ' + \ 3639 'meta: ' + repr(self.meta) + ' ' +\ 3640 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 3641 'valid: ' + repr(self.valid) + ' ' +\ 3642 '>' 3643 3644 def to_dict(self): 3645 return { 3646 'meta': self.meta, 3647 'rate_limit': self.rate_limit, 3648 'valid': self.valid, 3649 } 3650 3651 @classmethod 3652 def from_dict(cls, d): 3653 return cls( 3654 meta=d.get('meta'), 3655 rate_limit=d.get('rate_limit'), 3656 valid=d.get('valid'), 3657 ) 3658 3659 3660class CreateResponseMetadata: 3661 ''' 3662 CreateResponseMetadata is reserved for future use. 3663 ''' 3664 __slots__ = [] 3665 3666 def __init__(self, ): 3667 pass 3668 3669 def __repr__(self): 3670 return '<sdm.CreateResponseMetadata ' + \ 3671 '>' 3672 3673 def to_dict(self): 3674 return {} 3675 3676 @classmethod 3677 def from_dict(cls, d): 3678 return cls() 3679 3680 3681class DB2I: 3682 ''' 3683 3684 ''' 3685 __slots__ = [ 3686 'egress_filter', 3687 'healthy', 3688 'hostname', 3689 'id', 3690 'name', 3691 'password', 3692 'port', 3693 'port_override', 3694 'secret_store_id', 3695 'tags', 3696 'tls_required', 3697 'username', 3698 ] 3699 3700 def __init__( 3701 self, 3702 egress_filter=None, 3703 healthy=None, 3704 hostname=None, 3705 id=None, 3706 name=None, 3707 password=None, 3708 port=None, 3709 port_override=None, 3710 secret_store_id=None, 3711 tags=None, 3712 tls_required=None, 3713 username=None, 3714 ): 3715 self.egress_filter = egress_filter if egress_filter is not None else '' 3716 ''' 3717 A filter applied to the routing logic to pin datasource to nodes. 3718 ''' 3719 self.healthy = healthy if healthy is not None else False 3720 ''' 3721 True if the datasource is reachable and the credentials are valid. 3722 ''' 3723 self.hostname = hostname if hostname is not None else '' 3724 ''' 3725 3726 ''' 3727 self.id = id if id is not None else '' 3728 ''' 3729 Unique identifier of the Resource. 3730 ''' 3731 self.name = name if name is not None else '' 3732 ''' 3733 Unique human-readable name of the Resource. 3734 ''' 3735 self.password = password if password is not None else '' 3736 ''' 3737 3738 ''' 3739 self.port = port if port is not None else 0 3740 ''' 3741 3742 ''' 3743 self.port_override = port_override if port_override is not None else 0 3744 ''' 3745 3746 ''' 3747 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 3748 ''' 3749 ID of the secret store containing credentials for this resource, if any. 3750 ''' 3751 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 3752 ''' 3753 Tags is a map of key, value pairs. 3754 ''' 3755 self.tls_required = tls_required if tls_required is not None else False 3756 ''' 3757 3758 ''' 3759 self.username = username if username is not None else '' 3760 ''' 3761 3762 ''' 3763 3764 def __repr__(self): 3765 return '<sdm.DB2I ' + \ 3766 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 3767 'healthy: ' + repr(self.healthy) + ' ' +\ 3768 'hostname: ' + repr(self.hostname) + ' ' +\ 3769 'id: ' + repr(self.id) + ' ' +\ 3770 'name: ' + repr(self.name) + ' ' +\ 3771 'password: ' + repr(self.password) + ' ' +\ 3772 'port: ' + repr(self.port) + ' ' +\ 3773 'port_override: ' + repr(self.port_override) + ' ' +\ 3774 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 3775 'tags: ' + repr(self.tags) + ' ' +\ 3776 'tls_required: ' + repr(self.tls_required) + ' ' +\ 3777 'username: ' + repr(self.username) + ' ' +\ 3778 '>' 3779 3780 def to_dict(self): 3781 return { 3782 'egress_filter': self.egress_filter, 3783 'healthy': self.healthy, 3784 'hostname': self.hostname, 3785 'id': self.id, 3786 'name': self.name, 3787 'password': self.password, 3788 'port': self.port, 3789 'port_override': self.port_override, 3790 'secret_store_id': self.secret_store_id, 3791 'tags': self.tags, 3792 'tls_required': self.tls_required, 3793 'username': self.username, 3794 } 3795 3796 @classmethod 3797 def from_dict(cls, d): 3798 return cls( 3799 egress_filter=d.get('egress_filter'), 3800 healthy=d.get('healthy'), 3801 hostname=d.get('hostname'), 3802 id=d.get('id'), 3803 name=d.get('name'), 3804 password=d.get('password'), 3805 port=d.get('port'), 3806 port_override=d.get('port_override'), 3807 secret_store_id=d.get('secret_store_id'), 3808 tags=d.get('tags'), 3809 tls_required=d.get('tls_required'), 3810 username=d.get('username'), 3811 ) 3812 3813 3814class DB2LUW: 3815 ''' 3816 3817 ''' 3818 __slots__ = [ 3819 'database', 3820 'egress_filter', 3821 'healthy', 3822 'hostname', 3823 'id', 3824 'name', 3825 'password', 3826 'port', 3827 'port_override', 3828 'secret_store_id', 3829 'tags', 3830 'username', 3831 ] 3832 3833 def __init__( 3834 self, 3835 database=None, 3836 egress_filter=None, 3837 healthy=None, 3838 hostname=None, 3839 id=None, 3840 name=None, 3841 password=None, 3842 port=None, 3843 port_override=None, 3844 secret_store_id=None, 3845 tags=None, 3846 username=None, 3847 ): 3848 self.database = database if database is not None else '' 3849 ''' 3850 3851 ''' 3852 self.egress_filter = egress_filter if egress_filter is not None else '' 3853 ''' 3854 A filter applied to the routing logic to pin datasource to nodes. 3855 ''' 3856 self.healthy = healthy if healthy is not None else False 3857 ''' 3858 True if the datasource is reachable and the credentials are valid. 3859 ''' 3860 self.hostname = hostname if hostname is not None else '' 3861 ''' 3862 3863 ''' 3864 self.id = id if id is not None else '' 3865 ''' 3866 Unique identifier of the Resource. 3867 ''' 3868 self.name = name if name is not None else '' 3869 ''' 3870 Unique human-readable name of the Resource. 3871 ''' 3872 self.password = password if password is not None else '' 3873 ''' 3874 3875 ''' 3876 self.port = port if port is not None else 0 3877 ''' 3878 3879 ''' 3880 self.port_override = port_override if port_override is not None else 0 3881 ''' 3882 3883 ''' 3884 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 3885 ''' 3886 ID of the secret store containing credentials for this resource, if any. 3887 ''' 3888 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 3889 ''' 3890 Tags is a map of key, value pairs. 3891 ''' 3892 self.username = username if username is not None else '' 3893 ''' 3894 3895 ''' 3896 3897 def __repr__(self): 3898 return '<sdm.DB2LUW ' + \ 3899 'database: ' + repr(self.database) + ' ' +\ 3900 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 3901 'healthy: ' + repr(self.healthy) + ' ' +\ 3902 'hostname: ' + repr(self.hostname) + ' ' +\ 3903 'id: ' + repr(self.id) + ' ' +\ 3904 'name: ' + repr(self.name) + ' ' +\ 3905 'password: ' + repr(self.password) + ' ' +\ 3906 'port: ' + repr(self.port) + ' ' +\ 3907 'port_override: ' + repr(self.port_override) + ' ' +\ 3908 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 3909 'tags: ' + repr(self.tags) + ' ' +\ 3910 'username: ' + repr(self.username) + ' ' +\ 3911 '>' 3912 3913 def to_dict(self): 3914 return { 3915 'database': self.database, 3916 'egress_filter': self.egress_filter, 3917 'healthy': self.healthy, 3918 'hostname': self.hostname, 3919 'id': self.id, 3920 'name': self.name, 3921 'password': self.password, 3922 'port': self.port, 3923 'port_override': self.port_override, 3924 'secret_store_id': self.secret_store_id, 3925 'tags': self.tags, 3926 'username': self.username, 3927 } 3928 3929 @classmethod 3930 def from_dict(cls, d): 3931 return cls( 3932 database=d.get('database'), 3933 egress_filter=d.get('egress_filter'), 3934 healthy=d.get('healthy'), 3935 hostname=d.get('hostname'), 3936 id=d.get('id'), 3937 name=d.get('name'), 3938 password=d.get('password'), 3939 port=d.get('port'), 3940 port_override=d.get('port_override'), 3941 secret_store_id=d.get('secret_store_id'), 3942 tags=d.get('tags'), 3943 username=d.get('username'), 3944 ) 3945 3946 3947class DeleteResponseMetadata: 3948 ''' 3949 DeleteResponseMetadata is reserved for future use. 3950 ''' 3951 __slots__ = [] 3952 3953 def __init__(self, ): 3954 pass 3955 3956 def __repr__(self): 3957 return '<sdm.DeleteResponseMetadata ' + \ 3958 '>' 3959 3960 def to_dict(self): 3961 return {} 3962 3963 @classmethod 3964 def from_dict(cls, d): 3965 return cls() 3966 3967 3968class DocumentDBHost: 3969 ''' 3970 3971 ''' 3972 __slots__ = [ 3973 'auth_database', 3974 'egress_filter', 3975 'healthy', 3976 'hostname', 3977 'id', 3978 'name', 3979 'password', 3980 'port', 3981 'port_override', 3982 'secret_store_id', 3983 'tags', 3984 'username', 3985 ] 3986 3987 def __init__( 3988 self, 3989 auth_database=None, 3990 egress_filter=None, 3991 healthy=None, 3992 hostname=None, 3993 id=None, 3994 name=None, 3995 password=None, 3996 port=None, 3997 port_override=None, 3998 secret_store_id=None, 3999 tags=None, 4000 username=None, 4001 ): 4002 self.auth_database = auth_database if auth_database is not None else '' 4003 ''' 4004 4005 ''' 4006 self.egress_filter = egress_filter if egress_filter is not None else '' 4007 ''' 4008 A filter applied to the routing logic to pin datasource to nodes. 4009 ''' 4010 self.healthy = healthy if healthy is not None else False 4011 ''' 4012 True if the datasource is reachable and the credentials are valid. 4013 ''' 4014 self.hostname = hostname if hostname is not None else '' 4015 ''' 4016 4017 ''' 4018 self.id = id if id is not None else '' 4019 ''' 4020 Unique identifier of the Resource. 4021 ''' 4022 self.name = name if name is not None else '' 4023 ''' 4024 Unique human-readable name of the Resource. 4025 ''' 4026 self.password = password if password is not None else '' 4027 ''' 4028 4029 ''' 4030 self.port = port if port is not None else 0 4031 ''' 4032 4033 ''' 4034 self.port_override = port_override if port_override is not None else 0 4035 ''' 4036 4037 ''' 4038 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 4039 ''' 4040 ID of the secret store containing credentials for this resource, if any. 4041 ''' 4042 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 4043 ''' 4044 Tags is a map of key, value pairs. 4045 ''' 4046 self.username = username if username is not None else '' 4047 ''' 4048 4049 ''' 4050 4051 def __repr__(self): 4052 return '<sdm.DocumentDBHost ' + \ 4053 'auth_database: ' + repr(self.auth_database) + ' ' +\ 4054 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 4055 'healthy: ' + repr(self.healthy) + ' ' +\ 4056 'hostname: ' + repr(self.hostname) + ' ' +\ 4057 'id: ' + repr(self.id) + ' ' +\ 4058 'name: ' + repr(self.name) + ' ' +\ 4059 'password: ' + repr(self.password) + ' ' +\ 4060 'port: ' + repr(self.port) + ' ' +\ 4061 'port_override: ' + repr(self.port_override) + ' ' +\ 4062 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 4063 'tags: ' + repr(self.tags) + ' ' +\ 4064 'username: ' + repr(self.username) + ' ' +\ 4065 '>' 4066 4067 def to_dict(self): 4068 return { 4069 'auth_database': self.auth_database, 4070 'egress_filter': self.egress_filter, 4071 'healthy': self.healthy, 4072 'hostname': self.hostname, 4073 'id': self.id, 4074 'name': self.name, 4075 'password': self.password, 4076 'port': self.port, 4077 'port_override': self.port_override, 4078 'secret_store_id': self.secret_store_id, 4079 'tags': self.tags, 4080 'username': self.username, 4081 } 4082 4083 @classmethod 4084 def from_dict(cls, d): 4085 return cls( 4086 auth_database=d.get('auth_database'), 4087 egress_filter=d.get('egress_filter'), 4088 healthy=d.get('healthy'), 4089 hostname=d.get('hostname'), 4090 id=d.get('id'), 4091 name=d.get('name'), 4092 password=d.get('password'), 4093 port=d.get('port'), 4094 port_override=d.get('port_override'), 4095 secret_store_id=d.get('secret_store_id'), 4096 tags=d.get('tags'), 4097 username=d.get('username'), 4098 ) 4099 4100 4101class DocumentDBReplicaSet: 4102 ''' 4103 4104 ''' 4105 __slots__ = [ 4106 'auth_database', 4107 'connect_to_replica', 4108 'egress_filter', 4109 'healthy', 4110 'hostname', 4111 'id', 4112 'name', 4113 'password', 4114 'port_override', 4115 'replica_set', 4116 'secret_store_id', 4117 'tags', 4118 'username', 4119 ] 4120 4121 def __init__( 4122 self, 4123 auth_database=None, 4124 connect_to_replica=None, 4125 egress_filter=None, 4126 healthy=None, 4127 hostname=None, 4128 id=None, 4129 name=None, 4130 password=None, 4131 port_override=None, 4132 replica_set=None, 4133 secret_store_id=None, 4134 tags=None, 4135 username=None, 4136 ): 4137 self.auth_database = auth_database if auth_database is not None else '' 4138 ''' 4139 4140 ''' 4141 self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False 4142 ''' 4143 4144 ''' 4145 self.egress_filter = egress_filter if egress_filter is not None else '' 4146 ''' 4147 A filter applied to the routing logic to pin datasource to nodes. 4148 ''' 4149 self.healthy = healthy if healthy is not None else False 4150 ''' 4151 True if the datasource is reachable and the credentials are valid. 4152 ''' 4153 self.hostname = hostname if hostname is not None else '' 4154 ''' 4155 Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas. 4156 ''' 4157 self.id = id if id is not None else '' 4158 ''' 4159 Unique identifier of the Resource. 4160 ''' 4161 self.name = name if name is not None else '' 4162 ''' 4163 Unique human-readable name of the Resource. 4164 ''' 4165 self.password = password if password is not None else '' 4166 ''' 4167 4168 ''' 4169 self.port_override = port_override if port_override is not None else 0 4170 ''' 4171 4172 ''' 4173 self.replica_set = replica_set if replica_set is not None else '' 4174 ''' 4175 4176 ''' 4177 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 4178 ''' 4179 ID of the secret store containing credentials for this resource, if any. 4180 ''' 4181 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 4182 ''' 4183 Tags is a map of key, value pairs. 4184 ''' 4185 self.username = username if username is not None else '' 4186 ''' 4187 4188 ''' 4189 4190 def __repr__(self): 4191 return '<sdm.DocumentDBReplicaSet ' + \ 4192 'auth_database: ' + repr(self.auth_database) + ' ' +\ 4193 'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\ 4194 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 4195 'healthy: ' + repr(self.healthy) + ' ' +\ 4196 'hostname: ' + repr(self.hostname) + ' ' +\ 4197 'id: ' + repr(self.id) + ' ' +\ 4198 'name: ' + repr(self.name) + ' ' +\ 4199 'password: ' + repr(self.password) + ' ' +\ 4200 'port_override: ' + repr(self.port_override) + ' ' +\ 4201 'replica_set: ' + repr(self.replica_set) + ' ' +\ 4202 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 4203 'tags: ' + repr(self.tags) + ' ' +\ 4204 'username: ' + repr(self.username) + ' ' +\ 4205 '>' 4206 4207 def to_dict(self): 4208 return { 4209 'auth_database': self.auth_database, 4210 'connect_to_replica': self.connect_to_replica, 4211 'egress_filter': self.egress_filter, 4212 'healthy': self.healthy, 4213 'hostname': self.hostname, 4214 'id': self.id, 4215 'name': self.name, 4216 'password': self.password, 4217 'port_override': self.port_override, 4218 'replica_set': self.replica_set, 4219 'secret_store_id': self.secret_store_id, 4220 'tags': self.tags, 4221 'username': self.username, 4222 } 4223 4224 @classmethod 4225 def from_dict(cls, d): 4226 return cls( 4227 auth_database=d.get('auth_database'), 4228 connect_to_replica=d.get('connect_to_replica'), 4229 egress_filter=d.get('egress_filter'), 4230 healthy=d.get('healthy'), 4231 hostname=d.get('hostname'), 4232 id=d.get('id'), 4233 name=d.get('name'), 4234 password=d.get('password'), 4235 port_override=d.get('port_override'), 4236 replica_set=d.get('replica_set'), 4237 secret_store_id=d.get('secret_store_id'), 4238 tags=d.get('tags'), 4239 username=d.get('username'), 4240 ) 4241 4242 4243class Druid: 4244 ''' 4245 4246 ''' 4247 __slots__ = [ 4248 'egress_filter', 4249 'healthy', 4250 'hostname', 4251 'id', 4252 'name', 4253 'password', 4254 'port', 4255 'port_override', 4256 'secret_store_id', 4257 'tags', 4258 'username', 4259 ] 4260 4261 def __init__( 4262 self, 4263 egress_filter=None, 4264 healthy=None, 4265 hostname=None, 4266 id=None, 4267 name=None, 4268 password=None, 4269 port=None, 4270 port_override=None, 4271 secret_store_id=None, 4272 tags=None, 4273 username=None, 4274 ): 4275 self.egress_filter = egress_filter if egress_filter is not None else '' 4276 ''' 4277 A filter applied to the routing logic to pin datasource to nodes. 4278 ''' 4279 self.healthy = healthy if healthy is not None else False 4280 ''' 4281 True if the datasource is reachable and the credentials are valid. 4282 ''' 4283 self.hostname = hostname if hostname is not None else '' 4284 ''' 4285 4286 ''' 4287 self.id = id if id is not None else '' 4288 ''' 4289 Unique identifier of the Resource. 4290 ''' 4291 self.name = name if name is not None else '' 4292 ''' 4293 Unique human-readable name of the Resource. 4294 ''' 4295 self.password = password if password is not None else '' 4296 ''' 4297 4298 ''' 4299 self.port = port if port is not None else 0 4300 ''' 4301 4302 ''' 4303 self.port_override = port_override if port_override is not None else 0 4304 ''' 4305 4306 ''' 4307 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 4308 ''' 4309 ID of the secret store containing credentials for this resource, if any. 4310 ''' 4311 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 4312 ''' 4313 Tags is a map of key, value pairs. 4314 ''' 4315 self.username = username if username is not None else '' 4316 ''' 4317 4318 ''' 4319 4320 def __repr__(self): 4321 return '<sdm.Druid ' + \ 4322 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 4323 'healthy: ' + repr(self.healthy) + ' ' +\ 4324 'hostname: ' + repr(self.hostname) + ' ' +\ 4325 'id: ' + repr(self.id) + ' ' +\ 4326 'name: ' + repr(self.name) + ' ' +\ 4327 'password: ' + repr(self.password) + ' ' +\ 4328 'port: ' + repr(self.port) + ' ' +\ 4329 'port_override: ' + repr(self.port_override) + ' ' +\ 4330 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 4331 'tags: ' + repr(self.tags) + ' ' +\ 4332 'username: ' + repr(self.username) + ' ' +\ 4333 '>' 4334 4335 def to_dict(self): 4336 return { 4337 'egress_filter': self.egress_filter, 4338 'healthy': self.healthy, 4339 'hostname': self.hostname, 4340 'id': self.id, 4341 'name': self.name, 4342 'password': self.password, 4343 'port': self.port, 4344 'port_override': self.port_override, 4345 'secret_store_id': self.secret_store_id, 4346 'tags': self.tags, 4347 'username': self.username, 4348 } 4349 4350 @classmethod 4351 def from_dict(cls, d): 4352 return cls( 4353 egress_filter=d.get('egress_filter'), 4354 healthy=d.get('healthy'), 4355 hostname=d.get('hostname'), 4356 id=d.get('id'), 4357 name=d.get('name'), 4358 password=d.get('password'), 4359 port=d.get('port'), 4360 port_override=d.get('port_override'), 4361 secret_store_id=d.get('secret_store_id'), 4362 tags=d.get('tags'), 4363 username=d.get('username'), 4364 ) 4365 4366 4367class DynamoDB: 4368 ''' 4369 4370 ''' 4371 __slots__ = [ 4372 'access_key', 4373 'egress_filter', 4374 'endpoint', 4375 'healthy', 4376 'id', 4377 'name', 4378 'port_override', 4379 'region', 4380 'role_arn', 4381 'role_external_id', 4382 'secret_access_key', 4383 'secret_store_id', 4384 'tags', 4385 ] 4386 4387 def __init__( 4388 self, 4389 access_key=None, 4390 egress_filter=None, 4391 endpoint=None, 4392 healthy=None, 4393 id=None, 4394 name=None, 4395 port_override=None, 4396 region=None, 4397 role_arn=None, 4398 role_external_id=None, 4399 secret_access_key=None, 4400 secret_store_id=None, 4401 tags=None, 4402 ): 4403 self.access_key = access_key if access_key is not None else '' 4404 ''' 4405 4406 ''' 4407 self.egress_filter = egress_filter if egress_filter is not None else '' 4408 ''' 4409 A filter applied to the routing logic to pin datasource to nodes. 4410 ''' 4411 self.endpoint = endpoint if endpoint is not None else '' 4412 ''' 4413 4414 ''' 4415 self.healthy = healthy if healthy is not None else False 4416 ''' 4417 True if the datasource is reachable and the credentials are valid. 4418 ''' 4419 self.id = id if id is not None else '' 4420 ''' 4421 Unique identifier of the Resource. 4422 ''' 4423 self.name = name if name is not None else '' 4424 ''' 4425 Unique human-readable name of the Resource. 4426 ''' 4427 self.port_override = port_override if port_override is not None else 0 4428 ''' 4429 4430 ''' 4431 self.region = region if region is not None else '' 4432 ''' 4433 4434 ''' 4435 self.role_arn = role_arn if role_arn is not None else '' 4436 ''' 4437 4438 ''' 4439 self.role_external_id = role_external_id if role_external_id is not None else '' 4440 ''' 4441 4442 ''' 4443 self.secret_access_key = secret_access_key if secret_access_key is not None else '' 4444 ''' 4445 4446 ''' 4447 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 4448 ''' 4449 ID of the secret store containing credentials for this resource, if any. 4450 ''' 4451 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 4452 ''' 4453 Tags is a map of key, value pairs. 4454 ''' 4455 4456 def __repr__(self): 4457 return '<sdm.DynamoDB ' + \ 4458 'access_key: ' + repr(self.access_key) + ' ' +\ 4459 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 4460 'endpoint: ' + repr(self.endpoint) + ' ' +\ 4461 'healthy: ' + repr(self.healthy) + ' ' +\ 4462 'id: ' + repr(self.id) + ' ' +\ 4463 'name: ' + repr(self.name) + ' ' +\ 4464 'port_override: ' + repr(self.port_override) + ' ' +\ 4465 'region: ' + repr(self.region) + ' ' +\ 4466 'role_arn: ' + repr(self.role_arn) + ' ' +\ 4467 'role_external_id: ' + repr(self.role_external_id) + ' ' +\ 4468 'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\ 4469 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 4470 'tags: ' + repr(self.tags) + ' ' +\ 4471 '>' 4472 4473 def to_dict(self): 4474 return { 4475 'access_key': self.access_key, 4476 'egress_filter': self.egress_filter, 4477 'endpoint': self.endpoint, 4478 'healthy': self.healthy, 4479 'id': self.id, 4480 'name': self.name, 4481 'port_override': self.port_override, 4482 'region': self.region, 4483 'role_arn': self.role_arn, 4484 'role_external_id': self.role_external_id, 4485 'secret_access_key': self.secret_access_key, 4486 'secret_store_id': self.secret_store_id, 4487 'tags': self.tags, 4488 } 4489 4490 @classmethod 4491 def from_dict(cls, d): 4492 return cls( 4493 access_key=d.get('access_key'), 4494 egress_filter=d.get('egress_filter'), 4495 endpoint=d.get('endpoint'), 4496 healthy=d.get('healthy'), 4497 id=d.get('id'), 4498 name=d.get('name'), 4499 port_override=d.get('port_override'), 4500 region=d.get('region'), 4501 role_arn=d.get('role_arn'), 4502 role_external_id=d.get('role_external_id'), 4503 secret_access_key=d.get('secret_access_key'), 4504 secret_store_id=d.get('secret_store_id'), 4505 tags=d.get('tags'), 4506 ) 4507 4508 4509class Elastic: 4510 ''' 4511 4512 ''' 4513 __slots__ = [ 4514 'egress_filter', 4515 'healthy', 4516 'hostname', 4517 'id', 4518 'name', 4519 'password', 4520 'port', 4521 'port_override', 4522 'secret_store_id', 4523 'tags', 4524 'tls_required', 4525 'username', 4526 ] 4527 4528 def __init__( 4529 self, 4530 egress_filter=None, 4531 healthy=None, 4532 hostname=None, 4533 id=None, 4534 name=None, 4535 password=None, 4536 port=None, 4537 port_override=None, 4538 secret_store_id=None, 4539 tags=None, 4540 tls_required=None, 4541 username=None, 4542 ): 4543 self.egress_filter = egress_filter if egress_filter is not None else '' 4544 ''' 4545 A filter applied to the routing logic to pin datasource to nodes. 4546 ''' 4547 self.healthy = healthy if healthy is not None else False 4548 ''' 4549 True if the datasource is reachable and the credentials are valid. 4550 ''' 4551 self.hostname = hostname if hostname is not None else '' 4552 ''' 4553 4554 ''' 4555 self.id = id if id is not None else '' 4556 ''' 4557 Unique identifier of the Resource. 4558 ''' 4559 self.name = name if name is not None else '' 4560 ''' 4561 Unique human-readable name of the Resource. 4562 ''' 4563 self.password = password if password is not None else '' 4564 ''' 4565 4566 ''' 4567 self.port = port if port is not None else 0 4568 ''' 4569 4570 ''' 4571 self.port_override = port_override if port_override is not None else 0 4572 ''' 4573 4574 ''' 4575 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 4576 ''' 4577 ID of the secret store containing credentials for this resource, if any. 4578 ''' 4579 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 4580 ''' 4581 Tags is a map of key, value pairs. 4582 ''' 4583 self.tls_required = tls_required if tls_required is not None else False 4584 ''' 4585 4586 ''' 4587 self.username = username if username is not None else '' 4588 ''' 4589 4590 ''' 4591 4592 def __repr__(self): 4593 return '<sdm.Elastic ' + \ 4594 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 4595 'healthy: ' + repr(self.healthy) + ' ' +\ 4596 'hostname: ' + repr(self.hostname) + ' ' +\ 4597 'id: ' + repr(self.id) + ' ' +\ 4598 'name: ' + repr(self.name) + ' ' +\ 4599 'password: ' + repr(self.password) + ' ' +\ 4600 'port: ' + repr(self.port) + ' ' +\ 4601 'port_override: ' + repr(self.port_override) + ' ' +\ 4602 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 4603 'tags: ' + repr(self.tags) + ' ' +\ 4604 'tls_required: ' + repr(self.tls_required) + ' ' +\ 4605 'username: ' + repr(self.username) + ' ' +\ 4606 '>' 4607 4608 def to_dict(self): 4609 return { 4610 'egress_filter': self.egress_filter, 4611 'healthy': self.healthy, 4612 'hostname': self.hostname, 4613 'id': self.id, 4614 'name': self.name, 4615 'password': self.password, 4616 'port': self.port, 4617 'port_override': self.port_override, 4618 'secret_store_id': self.secret_store_id, 4619 'tags': self.tags, 4620 'tls_required': self.tls_required, 4621 'username': self.username, 4622 } 4623 4624 @classmethod 4625 def from_dict(cls, d): 4626 return cls( 4627 egress_filter=d.get('egress_filter'), 4628 healthy=d.get('healthy'), 4629 hostname=d.get('hostname'), 4630 id=d.get('id'), 4631 name=d.get('name'), 4632 password=d.get('password'), 4633 port=d.get('port'), 4634 port_override=d.get('port_override'), 4635 secret_store_id=d.get('secret_store_id'), 4636 tags=d.get('tags'), 4637 tls_required=d.get('tls_required'), 4638 username=d.get('username'), 4639 ) 4640 4641 4642class ElasticacheRedis: 4643 ''' 4644 4645 ''' 4646 __slots__ = [ 4647 'egress_filter', 4648 'healthy', 4649 'hostname', 4650 'id', 4651 'name', 4652 'password', 4653 'port', 4654 'port_override', 4655 'secret_store_id', 4656 'tags', 4657 'tls_required', 4658 ] 4659 4660 def __init__( 4661 self, 4662 egress_filter=None, 4663 healthy=None, 4664 hostname=None, 4665 id=None, 4666 name=None, 4667 password=None, 4668 port=None, 4669 port_override=None, 4670 secret_store_id=None, 4671 tags=None, 4672 tls_required=None, 4673 ): 4674 self.egress_filter = egress_filter if egress_filter is not None else '' 4675 ''' 4676 A filter applied to the routing logic to pin datasource to nodes. 4677 ''' 4678 self.healthy = healthy if healthy is not None else False 4679 ''' 4680 True if the datasource is reachable and the credentials are valid. 4681 ''' 4682 self.hostname = hostname if hostname is not None else '' 4683 ''' 4684 4685 ''' 4686 self.id = id if id is not None else '' 4687 ''' 4688 Unique identifier of the Resource. 4689 ''' 4690 self.name = name if name is not None else '' 4691 ''' 4692 Unique human-readable name of the Resource. 4693 ''' 4694 self.password = password if password is not None else '' 4695 ''' 4696 4697 ''' 4698 self.port = port if port is not None else 0 4699 ''' 4700 4701 ''' 4702 self.port_override = port_override if port_override is not None else 0 4703 ''' 4704 4705 ''' 4706 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 4707 ''' 4708 ID of the secret store containing credentials for this resource, if any. 4709 ''' 4710 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 4711 ''' 4712 Tags is a map of key, value pairs. 4713 ''' 4714 self.tls_required = tls_required if tls_required is not None else False 4715 ''' 4716 4717 ''' 4718 4719 def __repr__(self): 4720 return '<sdm.ElasticacheRedis ' + \ 4721 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 4722 'healthy: ' + repr(self.healthy) + ' ' +\ 4723 'hostname: ' + repr(self.hostname) + ' ' +\ 4724 'id: ' + repr(self.id) + ' ' +\ 4725 'name: ' + repr(self.name) + ' ' +\ 4726 'password: ' + repr(self.password) + ' ' +\ 4727 'port: ' + repr(self.port) + ' ' +\ 4728 'port_override: ' + repr(self.port_override) + ' ' +\ 4729 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 4730 'tags: ' + repr(self.tags) + ' ' +\ 4731 'tls_required: ' + repr(self.tls_required) + ' ' +\ 4732 '>' 4733 4734 def to_dict(self): 4735 return { 4736 'egress_filter': self.egress_filter, 4737 'healthy': self.healthy, 4738 'hostname': self.hostname, 4739 'id': self.id, 4740 'name': self.name, 4741 'password': self.password, 4742 'port': self.port, 4743 'port_override': self.port_override, 4744 'secret_store_id': self.secret_store_id, 4745 'tags': self.tags, 4746 'tls_required': self.tls_required, 4747 } 4748 4749 @classmethod 4750 def from_dict(cls, d): 4751 return cls( 4752 egress_filter=d.get('egress_filter'), 4753 healthy=d.get('healthy'), 4754 hostname=d.get('hostname'), 4755 id=d.get('id'), 4756 name=d.get('name'), 4757 password=d.get('password'), 4758 port=d.get('port'), 4759 port_override=d.get('port_override'), 4760 secret_store_id=d.get('secret_store_id'), 4761 tags=d.get('tags'), 4762 tls_required=d.get('tls_required'), 4763 ) 4764 4765 4766class GCP: 4767 ''' 4768 4769 ''' 4770 __slots__ = [ 4771 'egress_filter', 4772 'healthy', 4773 'id', 4774 'keyfile', 4775 'name', 4776 'scopes', 4777 'secret_store_id', 4778 'tags', 4779 ] 4780 4781 def __init__( 4782 self, 4783 egress_filter=None, 4784 healthy=None, 4785 id=None, 4786 keyfile=None, 4787 name=None, 4788 scopes=None, 4789 secret_store_id=None, 4790 tags=None, 4791 ): 4792 self.egress_filter = egress_filter if egress_filter is not None else '' 4793 ''' 4794 A filter applied to the routing logic to pin datasource to nodes. 4795 ''' 4796 self.healthy = healthy if healthy is not None else False 4797 ''' 4798 True if the datasource is reachable and the credentials are valid. 4799 ''' 4800 self.id = id if id is not None else '' 4801 ''' 4802 Unique identifier of the Resource. 4803 ''' 4804 self.keyfile = keyfile if keyfile is not None else '' 4805 ''' 4806 4807 ''' 4808 self.name = name if name is not None else '' 4809 ''' 4810 Unique human-readable name of the Resource. 4811 ''' 4812 self.scopes = scopes if scopes is not None else '' 4813 ''' 4814 4815 ''' 4816 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 4817 ''' 4818 ID of the secret store containing credentials for this resource, if any. 4819 ''' 4820 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 4821 ''' 4822 Tags is a map of key, value pairs. 4823 ''' 4824 4825 def __repr__(self): 4826 return '<sdm.GCP ' + \ 4827 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 4828 'healthy: ' + repr(self.healthy) + ' ' +\ 4829 'id: ' + repr(self.id) + ' ' +\ 4830 'keyfile: ' + repr(self.keyfile) + ' ' +\ 4831 'name: ' + repr(self.name) + ' ' +\ 4832 'scopes: ' + repr(self.scopes) + ' ' +\ 4833 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 4834 'tags: ' + repr(self.tags) + ' ' +\ 4835 '>' 4836 4837 def to_dict(self): 4838 return { 4839 'egress_filter': self.egress_filter, 4840 'healthy': self.healthy, 4841 'id': self.id, 4842 'keyfile': self.keyfile, 4843 'name': self.name, 4844 'scopes': self.scopes, 4845 'secret_store_id': self.secret_store_id, 4846 'tags': self.tags, 4847 } 4848 4849 @classmethod 4850 def from_dict(cls, d): 4851 return cls( 4852 egress_filter=d.get('egress_filter'), 4853 healthy=d.get('healthy'), 4854 id=d.get('id'), 4855 keyfile=d.get('keyfile'), 4856 name=d.get('name'), 4857 scopes=d.get('scopes'), 4858 secret_store_id=d.get('secret_store_id'), 4859 tags=d.get('tags'), 4860 ) 4861 4862 4863class GCPStore: 4864 ''' 4865 4866 ''' 4867 __slots__ = [ 4868 'id', 4869 'name', 4870 'projectid', 4871 'tags', 4872 ] 4873 4874 def __init__( 4875 self, 4876 id=None, 4877 name=None, 4878 projectid=None, 4879 tags=None, 4880 ): 4881 self.id = id if id is not None else '' 4882 ''' 4883 Unique identifier of the SecretStore. 4884 ''' 4885 self.name = name if name is not None else '' 4886 ''' 4887 Unique human-readable name of the SecretStore. 4888 ''' 4889 self.projectid = projectid if projectid is not None else '' 4890 ''' 4891 4892 ''' 4893 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 4894 ''' 4895 Tags is a map of key, value pairs. 4896 ''' 4897 4898 def __repr__(self): 4899 return '<sdm.GCPStore ' + \ 4900 'id: ' + repr(self.id) + ' ' +\ 4901 'name: ' + repr(self.name) + ' ' +\ 4902 'projectid: ' + repr(self.projectid) + ' ' +\ 4903 'tags: ' + repr(self.tags) + ' ' +\ 4904 '>' 4905 4906 def to_dict(self): 4907 return { 4908 'id': self.id, 4909 'name': self.name, 4910 'projectid': self.projectid, 4911 'tags': self.tags, 4912 } 4913 4914 @classmethod 4915 def from_dict(cls, d): 4916 return cls( 4917 id=d.get('id'), 4918 name=d.get('name'), 4919 projectid=d.get('projectid'), 4920 tags=d.get('tags'), 4921 ) 4922 4923 4924class Gateway: 4925 ''' 4926 Gateway represents a StrongDM CLI installation running in gateway mode. 4927 ''' 4928 __slots__ = [ 4929 'bind_address', 4930 'gateway_filter', 4931 'id', 4932 'listen_address', 4933 'name', 4934 'state', 4935 'tags', 4936 ] 4937 4938 def __init__( 4939 self, 4940 bind_address=None, 4941 gateway_filter=None, 4942 id=None, 4943 listen_address=None, 4944 name=None, 4945 state=None, 4946 tags=None, 4947 ): 4948 self.bind_address = bind_address if bind_address is not None else '' 4949 ''' 4950 The hostname/port tuple which the gateway daemon will bind to. 4951 If not provided on create, set to "0.0.0.0:listen_address_port". 4952 ''' 4953 self.gateway_filter = gateway_filter if gateway_filter is not None else '' 4954 ''' 4955 GatewayFilter can be used to restrict the peering between relays and 4956 gateways. 4957 ''' 4958 self.id = id if id is not None else '' 4959 ''' 4960 Unique identifier of the Gateway. 4961 ''' 4962 self.listen_address = listen_address if listen_address is not None else '' 4963 ''' 4964 The public hostname/port tuple at which the gateway will be accessible to clients. 4965 ''' 4966 self.name = name if name is not None else '' 4967 ''' 4968 Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create. 4969 ''' 4970 self.state = state if state is not None else '' 4971 ''' 4972 The current state of the gateway. One of: "new", "verifying_restart", 4973 "restarting", "started", "stopped", "dead", "unknown" 4974 ''' 4975 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 4976 ''' 4977 Tags is a map of key, value pairs. 4978 ''' 4979 4980 def __repr__(self): 4981 return '<sdm.Gateway ' + \ 4982 'bind_address: ' + repr(self.bind_address) + ' ' +\ 4983 'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\ 4984 'id: ' + repr(self.id) + ' ' +\ 4985 'listen_address: ' + repr(self.listen_address) + ' ' +\ 4986 'name: ' + repr(self.name) + ' ' +\ 4987 'state: ' + repr(self.state) + ' ' +\ 4988 'tags: ' + repr(self.tags) + ' ' +\ 4989 '>' 4990 4991 def to_dict(self): 4992 return { 4993 'bind_address': self.bind_address, 4994 'gateway_filter': self.gateway_filter, 4995 'id': self.id, 4996 'listen_address': self.listen_address, 4997 'name': self.name, 4998 'state': self.state, 4999 'tags': self.tags, 5000 } 5001 5002 @classmethod 5003 def from_dict(cls, d): 5004 return cls( 5005 bind_address=d.get('bind_address'), 5006 gateway_filter=d.get('gateway_filter'), 5007 id=d.get('id'), 5008 listen_address=d.get('listen_address'), 5009 name=d.get('name'), 5010 state=d.get('state'), 5011 tags=d.get('tags'), 5012 ) 5013 5014 5015class GetResponseMetadata: 5016 ''' 5017 GetResponseMetadata is reserved for future use. 5018 ''' 5019 __slots__ = [] 5020 5021 def __init__(self, ): 5022 pass 5023 5024 def __repr__(self): 5025 return '<sdm.GetResponseMetadata ' + \ 5026 '>' 5027 5028 def to_dict(self): 5029 return {} 5030 5031 @classmethod 5032 def from_dict(cls, d): 5033 return cls() 5034 5035 5036class GoogleGKE: 5037 ''' 5038 5039 ''' 5040 __slots__ = [ 5041 'certificate_authority', 5042 'egress_filter', 5043 'endpoint', 5044 'healthcheck_namespace', 5045 'healthy', 5046 'id', 5047 'name', 5048 'secret_store_id', 5049 'service_account_key', 5050 'tags', 5051 ] 5052 5053 def __init__( 5054 self, 5055 certificate_authority=None, 5056 egress_filter=None, 5057 endpoint=None, 5058 healthcheck_namespace=None, 5059 healthy=None, 5060 id=None, 5061 name=None, 5062 secret_store_id=None, 5063 service_account_key=None, 5064 tags=None, 5065 ): 5066 self.certificate_authority = certificate_authority if certificate_authority is not None else '' 5067 ''' 5068 5069 ''' 5070 self.egress_filter = egress_filter if egress_filter is not None else '' 5071 ''' 5072 A filter applied to the routing logic to pin datasource to nodes. 5073 ''' 5074 self.endpoint = endpoint if endpoint is not None else '' 5075 ''' 5076 5077 ''' 5078 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 5079 ''' 5080 The path used to check the health of your connection. Defaults to `default`. 5081 ''' 5082 self.healthy = healthy if healthy is not None else False 5083 ''' 5084 True if the datasource is reachable and the credentials are valid. 5085 ''' 5086 self.id = id if id is not None else '' 5087 ''' 5088 Unique identifier of the Resource. 5089 ''' 5090 self.name = name if name is not None else '' 5091 ''' 5092 Unique human-readable name of the Resource. 5093 ''' 5094 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 5095 ''' 5096 ID of the secret store containing credentials for this resource, if any. 5097 ''' 5098 self.service_account_key = service_account_key if service_account_key is not None else '' 5099 ''' 5100 5101 ''' 5102 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 5103 ''' 5104 Tags is a map of key, value pairs. 5105 ''' 5106 5107 def __repr__(self): 5108 return '<sdm.GoogleGKE ' + \ 5109 'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\ 5110 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 5111 'endpoint: ' + repr(self.endpoint) + ' ' +\ 5112 'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\ 5113 'healthy: ' + repr(self.healthy) + ' ' +\ 5114 'id: ' + repr(self.id) + ' ' +\ 5115 'name: ' + repr(self.name) + ' ' +\ 5116 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 5117 'service_account_key: ' + repr(self.service_account_key) + ' ' +\ 5118 'tags: ' + repr(self.tags) + ' ' +\ 5119 '>' 5120 5121 def to_dict(self): 5122 return { 5123 'certificate_authority': self.certificate_authority, 5124 'egress_filter': self.egress_filter, 5125 'endpoint': self.endpoint, 5126 'healthcheck_namespace': self.healthcheck_namespace, 5127 'healthy': self.healthy, 5128 'id': self.id, 5129 'name': self.name, 5130 'secret_store_id': self.secret_store_id, 5131 'service_account_key': self.service_account_key, 5132 'tags': self.tags, 5133 } 5134 5135 @classmethod 5136 def from_dict(cls, d): 5137 return cls( 5138 certificate_authority=d.get('certificate_authority'), 5139 egress_filter=d.get('egress_filter'), 5140 endpoint=d.get('endpoint'), 5141 healthcheck_namespace=d.get('healthcheck_namespace'), 5142 healthy=d.get('healthy'), 5143 id=d.get('id'), 5144 name=d.get('name'), 5145 secret_store_id=d.get('secret_store_id'), 5146 service_account_key=d.get('service_account_key'), 5147 tags=d.get('tags'), 5148 ) 5149 5150 5151class GoogleGKEUserImpersonation: 5152 ''' 5153 5154 ''' 5155 __slots__ = [ 5156 'certificate_authority', 5157 'egress_filter', 5158 'endpoint', 5159 'healthcheck_namespace', 5160 'healthy', 5161 'id', 5162 'name', 5163 'secret_store_id', 5164 'service_account_key', 5165 'tags', 5166 ] 5167 5168 def __init__( 5169 self, 5170 certificate_authority=None, 5171 egress_filter=None, 5172 endpoint=None, 5173 healthcheck_namespace=None, 5174 healthy=None, 5175 id=None, 5176 name=None, 5177 secret_store_id=None, 5178 service_account_key=None, 5179 tags=None, 5180 ): 5181 self.certificate_authority = certificate_authority if certificate_authority is not None else '' 5182 ''' 5183 5184 ''' 5185 self.egress_filter = egress_filter if egress_filter is not None else '' 5186 ''' 5187 A filter applied to the routing logic to pin datasource to nodes. 5188 ''' 5189 self.endpoint = endpoint if endpoint is not None else '' 5190 ''' 5191 5192 ''' 5193 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 5194 ''' 5195 The path used to check the health of your connection. Defaults to `default`. 5196 ''' 5197 self.healthy = healthy if healthy is not None else False 5198 ''' 5199 True if the datasource is reachable and the credentials are valid. 5200 ''' 5201 self.id = id if id is not None else '' 5202 ''' 5203 Unique identifier of the Resource. 5204 ''' 5205 self.name = name if name is not None else '' 5206 ''' 5207 Unique human-readable name of the Resource. 5208 ''' 5209 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 5210 ''' 5211 ID of the secret store containing credentials for this resource, if any. 5212 ''' 5213 self.service_account_key = service_account_key if service_account_key is not None else '' 5214 ''' 5215 5216 ''' 5217 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 5218 ''' 5219 Tags is a map of key, value pairs. 5220 ''' 5221 5222 def __repr__(self): 5223 return '<sdm.GoogleGKEUserImpersonation ' + \ 5224 'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\ 5225 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 5226 'endpoint: ' + repr(self.endpoint) + ' ' +\ 5227 'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\ 5228 'healthy: ' + repr(self.healthy) + ' ' +\ 5229 'id: ' + repr(self.id) + ' ' +\ 5230 'name: ' + repr(self.name) + ' ' +\ 5231 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 5232 'service_account_key: ' + repr(self.service_account_key) + ' ' +\ 5233 'tags: ' + repr(self.tags) + ' ' +\ 5234 '>' 5235 5236 def to_dict(self): 5237 return { 5238 'certificate_authority': self.certificate_authority, 5239 'egress_filter': self.egress_filter, 5240 'endpoint': self.endpoint, 5241 'healthcheck_namespace': self.healthcheck_namespace, 5242 'healthy': self.healthy, 5243 'id': self.id, 5244 'name': self.name, 5245 'secret_store_id': self.secret_store_id, 5246 'service_account_key': self.service_account_key, 5247 'tags': self.tags, 5248 } 5249 5250 @classmethod 5251 def from_dict(cls, d): 5252 return cls( 5253 certificate_authority=d.get('certificate_authority'), 5254 egress_filter=d.get('egress_filter'), 5255 endpoint=d.get('endpoint'), 5256 healthcheck_namespace=d.get('healthcheck_namespace'), 5257 healthy=d.get('healthy'), 5258 id=d.get('id'), 5259 name=d.get('name'), 5260 secret_store_id=d.get('secret_store_id'), 5261 service_account_key=d.get('service_account_key'), 5262 tags=d.get('tags'), 5263 ) 5264 5265 5266class Greenplum: 5267 ''' 5268 5269 ''' 5270 __slots__ = [ 5271 'database', 5272 'egress_filter', 5273 'healthy', 5274 'hostname', 5275 'id', 5276 'name', 5277 'override_database', 5278 'password', 5279 'port', 5280 'port_override', 5281 'secret_store_id', 5282 'tags', 5283 'username', 5284 ] 5285 5286 def __init__( 5287 self, 5288 database=None, 5289 egress_filter=None, 5290 healthy=None, 5291 hostname=None, 5292 id=None, 5293 name=None, 5294 override_database=None, 5295 password=None, 5296 port=None, 5297 port_override=None, 5298 secret_store_id=None, 5299 tags=None, 5300 username=None, 5301 ): 5302 self.database = database if database is not None else '' 5303 ''' 5304 5305 ''' 5306 self.egress_filter = egress_filter if egress_filter is not None else '' 5307 ''' 5308 A filter applied to the routing logic to pin datasource to nodes. 5309 ''' 5310 self.healthy = healthy if healthy is not None else False 5311 ''' 5312 True if the datasource is reachable and the credentials are valid. 5313 ''' 5314 self.hostname = hostname if hostname is not None else '' 5315 ''' 5316 5317 ''' 5318 self.id = id if id is not None else '' 5319 ''' 5320 Unique identifier of the Resource. 5321 ''' 5322 self.name = name if name is not None else '' 5323 ''' 5324 Unique human-readable name of the Resource. 5325 ''' 5326 self.override_database = override_database if override_database is not None else False 5327 ''' 5328 5329 ''' 5330 self.password = password if password is not None else '' 5331 ''' 5332 5333 ''' 5334 self.port = port if port is not None else 0 5335 ''' 5336 5337 ''' 5338 self.port_override = port_override if port_override is not None else 0 5339 ''' 5340 5341 ''' 5342 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 5343 ''' 5344 ID of the secret store containing credentials for this resource, if any. 5345 ''' 5346 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 5347 ''' 5348 Tags is a map of key, value pairs. 5349 ''' 5350 self.username = username if username is not None else '' 5351 ''' 5352 5353 ''' 5354 5355 def __repr__(self): 5356 return '<sdm.Greenplum ' + \ 5357 'database: ' + repr(self.database) + ' ' +\ 5358 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 5359 'healthy: ' + repr(self.healthy) + ' ' +\ 5360 'hostname: ' + repr(self.hostname) + ' ' +\ 5361 'id: ' + repr(self.id) + ' ' +\ 5362 'name: ' + repr(self.name) + ' ' +\ 5363 'override_database: ' + repr(self.override_database) + ' ' +\ 5364 'password: ' + repr(self.password) + ' ' +\ 5365 'port: ' + repr(self.port) + ' ' +\ 5366 'port_override: ' + repr(self.port_override) + ' ' +\ 5367 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 5368 'tags: ' + repr(self.tags) + ' ' +\ 5369 'username: ' + repr(self.username) + ' ' +\ 5370 '>' 5371 5372 def to_dict(self): 5373 return { 5374 'database': self.database, 5375 'egress_filter': self.egress_filter, 5376 'healthy': self.healthy, 5377 'hostname': self.hostname, 5378 'id': self.id, 5379 'name': self.name, 5380 'override_database': self.override_database, 5381 'password': self.password, 5382 'port': self.port, 5383 'port_override': self.port_override, 5384 'secret_store_id': self.secret_store_id, 5385 'tags': self.tags, 5386 'username': self.username, 5387 } 5388 5389 @classmethod 5390 def from_dict(cls, d): 5391 return cls( 5392 database=d.get('database'), 5393 egress_filter=d.get('egress_filter'), 5394 healthy=d.get('healthy'), 5395 hostname=d.get('hostname'), 5396 id=d.get('id'), 5397 name=d.get('name'), 5398 override_database=d.get('override_database'), 5399 password=d.get('password'), 5400 port=d.get('port'), 5401 port_override=d.get('port_override'), 5402 secret_store_id=d.get('secret_store_id'), 5403 tags=d.get('tags'), 5404 username=d.get('username'), 5405 ) 5406 5407 5408class HTTPAuth: 5409 ''' 5410 5411 ''' 5412 __slots__ = [ 5413 'auth_header', 5414 'default_path', 5415 'egress_filter', 5416 'headers_blacklist', 5417 'healthcheck_path', 5418 'healthy', 5419 'id', 5420 'name', 5421 'secret_store_id', 5422 'subdomain', 5423 'tags', 5424 'url', 5425 ] 5426 5427 def __init__( 5428 self, 5429 auth_header=None, 5430 default_path=None, 5431 egress_filter=None, 5432 headers_blacklist=None, 5433 healthcheck_path=None, 5434 healthy=None, 5435 id=None, 5436 name=None, 5437 secret_store_id=None, 5438 subdomain=None, 5439 tags=None, 5440 url=None, 5441 ): 5442 self.auth_header = auth_header if auth_header is not None else '' 5443 ''' 5444 5445 ''' 5446 self.default_path = default_path if default_path is not None else '' 5447 ''' 5448 5449 ''' 5450 self.egress_filter = egress_filter if egress_filter is not None else '' 5451 ''' 5452 A filter applied to the routing logic to pin datasource to nodes. 5453 ''' 5454 self.headers_blacklist = headers_blacklist if headers_blacklist is not None else '' 5455 ''' 5456 5457 ''' 5458 self.healthcheck_path = healthcheck_path if healthcheck_path is not None else '' 5459 ''' 5460 5461 ''' 5462 self.healthy = healthy if healthy is not None else False 5463 ''' 5464 True if the datasource is reachable and the credentials are valid. 5465 ''' 5466 self.id = id if id is not None else '' 5467 ''' 5468 Unique identifier of the Resource. 5469 ''' 5470 self.name = name if name is not None else '' 5471 ''' 5472 Unique human-readable name of the Resource. 5473 ''' 5474 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 5475 ''' 5476 ID of the secret store containing credentials for this resource, if any. 5477 ''' 5478 self.subdomain = subdomain if subdomain is not None else '' 5479 ''' 5480 5481 ''' 5482 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 5483 ''' 5484 Tags is a map of key, value pairs. 5485 ''' 5486 self.url = url if url is not None else '' 5487 ''' 5488 5489 ''' 5490 5491 def __repr__(self): 5492 return '<sdm.HTTPAuth ' + \ 5493 'auth_header: ' + repr(self.auth_header) + ' ' +\ 5494 'default_path: ' + repr(self.default_path) + ' ' +\ 5495 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 5496 'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\ 5497 'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\ 5498 'healthy: ' + repr(self.healthy) + ' ' +\ 5499 'id: ' + repr(self.id) + ' ' +\ 5500 'name: ' + repr(self.name) + ' ' +\ 5501 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 5502 'subdomain: ' + repr(self.subdomain) + ' ' +\ 5503 'tags: ' + repr(self.tags) + ' ' +\ 5504 'url: ' + repr(self.url) + ' ' +\ 5505 '>' 5506 5507 def to_dict(self): 5508 return { 5509 'auth_header': self.auth_header, 5510 'default_path': self.default_path, 5511 'egress_filter': self.egress_filter, 5512 'headers_blacklist': self.headers_blacklist, 5513 'healthcheck_path': self.healthcheck_path, 5514 'healthy': self.healthy, 5515 'id': self.id, 5516 'name': self.name, 5517 'secret_store_id': self.secret_store_id, 5518 'subdomain': self.subdomain, 5519 'tags': self.tags, 5520 'url': self.url, 5521 } 5522 5523 @classmethod 5524 def from_dict(cls, d): 5525 return cls( 5526 auth_header=d.get('auth_header'), 5527 default_path=d.get('default_path'), 5528 egress_filter=d.get('egress_filter'), 5529 headers_blacklist=d.get('headers_blacklist'), 5530 healthcheck_path=d.get('healthcheck_path'), 5531 healthy=d.get('healthy'), 5532 id=d.get('id'), 5533 name=d.get('name'), 5534 secret_store_id=d.get('secret_store_id'), 5535 subdomain=d.get('subdomain'), 5536 tags=d.get('tags'), 5537 url=d.get('url'), 5538 ) 5539 5540 5541class HTTPBasicAuth: 5542 ''' 5543 5544 ''' 5545 __slots__ = [ 5546 'default_path', 5547 'egress_filter', 5548 'headers_blacklist', 5549 'healthcheck_path', 5550 'healthy', 5551 'id', 5552 'name', 5553 'password', 5554 'secret_store_id', 5555 'subdomain', 5556 'tags', 5557 'url', 5558 'username', 5559 ] 5560 5561 def __init__( 5562 self, 5563 default_path=None, 5564 egress_filter=None, 5565 headers_blacklist=None, 5566 healthcheck_path=None, 5567 healthy=None, 5568 id=None, 5569 name=None, 5570 password=None, 5571 secret_store_id=None, 5572 subdomain=None, 5573 tags=None, 5574 url=None, 5575 username=None, 5576 ): 5577 self.default_path = default_path if default_path is not None else '' 5578 ''' 5579 5580 ''' 5581 self.egress_filter = egress_filter if egress_filter is not None else '' 5582 ''' 5583 A filter applied to the routing logic to pin datasource to nodes. 5584 ''' 5585 self.headers_blacklist = headers_blacklist if headers_blacklist is not None else '' 5586 ''' 5587 5588 ''' 5589 self.healthcheck_path = healthcheck_path if healthcheck_path is not None else '' 5590 ''' 5591 5592 ''' 5593 self.healthy = healthy if healthy is not None else False 5594 ''' 5595 True if the datasource is reachable and the credentials are valid. 5596 ''' 5597 self.id = id if id is not None else '' 5598 ''' 5599 Unique identifier of the Resource. 5600 ''' 5601 self.name = name if name is not None else '' 5602 ''' 5603 Unique human-readable name of the Resource. 5604 ''' 5605 self.password = password if password is not None else '' 5606 ''' 5607 5608 ''' 5609 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 5610 ''' 5611 ID of the secret store containing credentials for this resource, if any. 5612 ''' 5613 self.subdomain = subdomain if subdomain is not None else '' 5614 ''' 5615 5616 ''' 5617 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 5618 ''' 5619 Tags is a map of key, value pairs. 5620 ''' 5621 self.url = url if url is not None else '' 5622 ''' 5623 5624 ''' 5625 self.username = username if username is not None else '' 5626 ''' 5627 5628 ''' 5629 5630 def __repr__(self): 5631 return '<sdm.HTTPBasicAuth ' + \ 5632 'default_path: ' + repr(self.default_path) + ' ' +\ 5633 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 5634 'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\ 5635 'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\ 5636 'healthy: ' + repr(self.healthy) + ' ' +\ 5637 'id: ' + repr(self.id) + ' ' +\ 5638 'name: ' + repr(self.name) + ' ' +\ 5639 'password: ' + repr(self.password) + ' ' +\ 5640 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 5641 'subdomain: ' + repr(self.subdomain) + ' ' +\ 5642 'tags: ' + repr(self.tags) + ' ' +\ 5643 'url: ' + repr(self.url) + ' ' +\ 5644 'username: ' + repr(self.username) + ' ' +\ 5645 '>' 5646 5647 def to_dict(self): 5648 return { 5649 'default_path': self.default_path, 5650 'egress_filter': self.egress_filter, 5651 'headers_blacklist': self.headers_blacklist, 5652 'healthcheck_path': self.healthcheck_path, 5653 'healthy': self.healthy, 5654 'id': self.id, 5655 'name': self.name, 5656 'password': self.password, 5657 'secret_store_id': self.secret_store_id, 5658 'subdomain': self.subdomain, 5659 'tags': self.tags, 5660 'url': self.url, 5661 'username': self.username, 5662 } 5663 5664 @classmethod 5665 def from_dict(cls, d): 5666 return cls( 5667 default_path=d.get('default_path'), 5668 egress_filter=d.get('egress_filter'), 5669 headers_blacklist=d.get('headers_blacklist'), 5670 healthcheck_path=d.get('healthcheck_path'), 5671 healthy=d.get('healthy'), 5672 id=d.get('id'), 5673 name=d.get('name'), 5674 password=d.get('password'), 5675 secret_store_id=d.get('secret_store_id'), 5676 subdomain=d.get('subdomain'), 5677 tags=d.get('tags'), 5678 url=d.get('url'), 5679 username=d.get('username'), 5680 ) 5681 5682 5683class HTTPNoAuth: 5684 ''' 5685 5686 ''' 5687 __slots__ = [ 5688 'default_path', 5689 'egress_filter', 5690 'headers_blacklist', 5691 'healthcheck_path', 5692 'healthy', 5693 'id', 5694 'name', 5695 'secret_store_id', 5696 'subdomain', 5697 'tags', 5698 'url', 5699 ] 5700 5701 def __init__( 5702 self, 5703 default_path=None, 5704 egress_filter=None, 5705 headers_blacklist=None, 5706 healthcheck_path=None, 5707 healthy=None, 5708 id=None, 5709 name=None, 5710 secret_store_id=None, 5711 subdomain=None, 5712 tags=None, 5713 url=None, 5714 ): 5715 self.default_path = default_path if default_path is not None else '' 5716 ''' 5717 5718 ''' 5719 self.egress_filter = egress_filter if egress_filter is not None else '' 5720 ''' 5721 A filter applied to the routing logic to pin datasource to nodes. 5722 ''' 5723 self.headers_blacklist = headers_blacklist if headers_blacklist is not None else '' 5724 ''' 5725 5726 ''' 5727 self.healthcheck_path = healthcheck_path if healthcheck_path is not None else '' 5728 ''' 5729 5730 ''' 5731 self.healthy = healthy if healthy is not None else False 5732 ''' 5733 True if the datasource is reachable and the credentials are valid. 5734 ''' 5735 self.id = id if id is not None else '' 5736 ''' 5737 Unique identifier of the Resource. 5738 ''' 5739 self.name = name if name is not None else '' 5740 ''' 5741 Unique human-readable name of the Resource. 5742 ''' 5743 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 5744 ''' 5745 ID of the secret store containing credentials for this resource, if any. 5746 ''' 5747 self.subdomain = subdomain if subdomain is not None else '' 5748 ''' 5749 5750 ''' 5751 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 5752 ''' 5753 Tags is a map of key, value pairs. 5754 ''' 5755 self.url = url if url is not None else '' 5756 ''' 5757 5758 ''' 5759 5760 def __repr__(self): 5761 return '<sdm.HTTPNoAuth ' + \ 5762 'default_path: ' + repr(self.default_path) + ' ' +\ 5763 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 5764 'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\ 5765 'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\ 5766 'healthy: ' + repr(self.healthy) + ' ' +\ 5767 'id: ' + repr(self.id) + ' ' +\ 5768 'name: ' + repr(self.name) + ' ' +\ 5769 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 5770 'subdomain: ' + repr(self.subdomain) + ' ' +\ 5771 'tags: ' + repr(self.tags) + ' ' +\ 5772 'url: ' + repr(self.url) + ' ' +\ 5773 '>' 5774 5775 def to_dict(self): 5776 return { 5777 'default_path': self.default_path, 5778 'egress_filter': self.egress_filter, 5779 'headers_blacklist': self.headers_blacklist, 5780 'healthcheck_path': self.healthcheck_path, 5781 'healthy': self.healthy, 5782 'id': self.id, 5783 'name': self.name, 5784 'secret_store_id': self.secret_store_id, 5785 'subdomain': self.subdomain, 5786 'tags': self.tags, 5787 'url': self.url, 5788 } 5789 5790 @classmethod 5791 def from_dict(cls, d): 5792 return cls( 5793 default_path=d.get('default_path'), 5794 egress_filter=d.get('egress_filter'), 5795 headers_blacklist=d.get('headers_blacklist'), 5796 healthcheck_path=d.get('healthcheck_path'), 5797 healthy=d.get('healthy'), 5798 id=d.get('id'), 5799 name=d.get('name'), 5800 secret_store_id=d.get('secret_store_id'), 5801 subdomain=d.get('subdomain'), 5802 tags=d.get('tags'), 5803 url=d.get('url'), 5804 ) 5805 5806 5807class Kubernetes: 5808 ''' 5809 5810 ''' 5811 __slots__ = [ 5812 'certificate_authority', 5813 'client_certificate', 5814 'client_key', 5815 'egress_filter', 5816 'healthcheck_namespace', 5817 'healthy', 5818 'hostname', 5819 'id', 5820 'name', 5821 'port', 5822 'secret_store_id', 5823 'tags', 5824 ] 5825 5826 def __init__( 5827 self, 5828 certificate_authority=None, 5829 client_certificate=None, 5830 client_key=None, 5831 egress_filter=None, 5832 healthcheck_namespace=None, 5833 healthy=None, 5834 hostname=None, 5835 id=None, 5836 name=None, 5837 port=None, 5838 secret_store_id=None, 5839 tags=None, 5840 ): 5841 self.certificate_authority = certificate_authority if certificate_authority is not None else '' 5842 ''' 5843 5844 ''' 5845 self.client_certificate = client_certificate if client_certificate is not None else '' 5846 ''' 5847 5848 ''' 5849 self.client_key = client_key if client_key is not None else '' 5850 ''' 5851 5852 ''' 5853 self.egress_filter = egress_filter if egress_filter is not None else '' 5854 ''' 5855 A filter applied to the routing logic to pin datasource to nodes. 5856 ''' 5857 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 5858 ''' 5859 The path used to check the health of your connection. Defaults to `default`. 5860 ''' 5861 self.healthy = healthy if healthy is not None else False 5862 ''' 5863 True if the datasource is reachable and the credentials are valid. 5864 ''' 5865 self.hostname = hostname if hostname is not None else '' 5866 ''' 5867 5868 ''' 5869 self.id = id if id is not None else '' 5870 ''' 5871 Unique identifier of the Resource. 5872 ''' 5873 self.name = name if name is not None else '' 5874 ''' 5875 Unique human-readable name of the Resource. 5876 ''' 5877 self.port = port if port is not None else 0 5878 ''' 5879 5880 ''' 5881 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 5882 ''' 5883 ID of the secret store containing credentials for this resource, if any. 5884 ''' 5885 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 5886 ''' 5887 Tags is a map of key, value pairs. 5888 ''' 5889 5890 def __repr__(self): 5891 return '<sdm.Kubernetes ' + \ 5892 'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\ 5893 'client_certificate: ' + repr(self.client_certificate) + ' ' +\ 5894 'client_key: ' + repr(self.client_key) + ' ' +\ 5895 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 5896 'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\ 5897 'healthy: ' + repr(self.healthy) + ' ' +\ 5898 'hostname: ' + repr(self.hostname) + ' ' +\ 5899 'id: ' + repr(self.id) + ' ' +\ 5900 'name: ' + repr(self.name) + ' ' +\ 5901 'port: ' + repr(self.port) + ' ' +\ 5902 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 5903 'tags: ' + repr(self.tags) + ' ' +\ 5904 '>' 5905 5906 def to_dict(self): 5907 return { 5908 'certificate_authority': self.certificate_authority, 5909 'client_certificate': self.client_certificate, 5910 'client_key': self.client_key, 5911 'egress_filter': self.egress_filter, 5912 'healthcheck_namespace': self.healthcheck_namespace, 5913 'healthy': self.healthy, 5914 'hostname': self.hostname, 5915 'id': self.id, 5916 'name': self.name, 5917 'port': self.port, 5918 'secret_store_id': self.secret_store_id, 5919 'tags': self.tags, 5920 } 5921 5922 @classmethod 5923 def from_dict(cls, d): 5924 return cls( 5925 certificate_authority=d.get('certificate_authority'), 5926 client_certificate=d.get('client_certificate'), 5927 client_key=d.get('client_key'), 5928 egress_filter=d.get('egress_filter'), 5929 healthcheck_namespace=d.get('healthcheck_namespace'), 5930 healthy=d.get('healthy'), 5931 hostname=d.get('hostname'), 5932 id=d.get('id'), 5933 name=d.get('name'), 5934 port=d.get('port'), 5935 secret_store_id=d.get('secret_store_id'), 5936 tags=d.get('tags'), 5937 ) 5938 5939 5940class KubernetesBasicAuth: 5941 ''' 5942 5943 ''' 5944 __slots__ = [ 5945 'egress_filter', 5946 'healthcheck_namespace', 5947 'healthy', 5948 'hostname', 5949 'id', 5950 'name', 5951 'password', 5952 'port', 5953 'secret_store_id', 5954 'tags', 5955 'username', 5956 ] 5957 5958 def __init__( 5959 self, 5960 egress_filter=None, 5961 healthcheck_namespace=None, 5962 healthy=None, 5963 hostname=None, 5964 id=None, 5965 name=None, 5966 password=None, 5967 port=None, 5968 secret_store_id=None, 5969 tags=None, 5970 username=None, 5971 ): 5972 self.egress_filter = egress_filter if egress_filter is not None else '' 5973 ''' 5974 A filter applied to the routing logic to pin datasource to nodes. 5975 ''' 5976 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 5977 ''' 5978 The path used to check the health of your connection. Defaults to `default`. 5979 ''' 5980 self.healthy = healthy if healthy is not None else False 5981 ''' 5982 True if the datasource is reachable and the credentials are valid. 5983 ''' 5984 self.hostname = hostname if hostname is not None else '' 5985 ''' 5986 5987 ''' 5988 self.id = id if id is not None else '' 5989 ''' 5990 Unique identifier of the Resource. 5991 ''' 5992 self.name = name if name is not None else '' 5993 ''' 5994 Unique human-readable name of the Resource. 5995 ''' 5996 self.password = password if password is not None else '' 5997 ''' 5998 5999 ''' 6000 self.port = port if port is not None else 0 6001 ''' 6002 6003 ''' 6004 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 6005 ''' 6006 ID of the secret store containing credentials for this resource, if any. 6007 ''' 6008 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 6009 ''' 6010 Tags is a map of key, value pairs. 6011 ''' 6012 self.username = username if username is not None else '' 6013 ''' 6014 6015 ''' 6016 6017 def __repr__(self): 6018 return '<sdm.KubernetesBasicAuth ' + \ 6019 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 6020 'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\ 6021 'healthy: ' + repr(self.healthy) + ' ' +\ 6022 'hostname: ' + repr(self.hostname) + ' ' +\ 6023 'id: ' + repr(self.id) + ' ' +\ 6024 'name: ' + repr(self.name) + ' ' +\ 6025 'password: ' + repr(self.password) + ' ' +\ 6026 'port: ' + repr(self.port) + ' ' +\ 6027 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 6028 'tags: ' + repr(self.tags) + ' ' +\ 6029 'username: ' + repr(self.username) + ' ' +\ 6030 '>' 6031 6032 def to_dict(self): 6033 return { 6034 'egress_filter': self.egress_filter, 6035 'healthcheck_namespace': self.healthcheck_namespace, 6036 'healthy': self.healthy, 6037 'hostname': self.hostname, 6038 'id': self.id, 6039 'name': self.name, 6040 'password': self.password, 6041 'port': self.port, 6042 'secret_store_id': self.secret_store_id, 6043 'tags': self.tags, 6044 'username': self.username, 6045 } 6046 6047 @classmethod 6048 def from_dict(cls, d): 6049 return cls( 6050 egress_filter=d.get('egress_filter'), 6051 healthcheck_namespace=d.get('healthcheck_namespace'), 6052 healthy=d.get('healthy'), 6053 hostname=d.get('hostname'), 6054 id=d.get('id'), 6055 name=d.get('name'), 6056 password=d.get('password'), 6057 port=d.get('port'), 6058 secret_store_id=d.get('secret_store_id'), 6059 tags=d.get('tags'), 6060 username=d.get('username'), 6061 ) 6062 6063 6064class KubernetesServiceAccount: 6065 ''' 6066 6067 ''' 6068 __slots__ = [ 6069 'egress_filter', 6070 'healthcheck_namespace', 6071 'healthy', 6072 'hostname', 6073 'id', 6074 'name', 6075 'port', 6076 'secret_store_id', 6077 'tags', 6078 'token', 6079 ] 6080 6081 def __init__( 6082 self, 6083 egress_filter=None, 6084 healthcheck_namespace=None, 6085 healthy=None, 6086 hostname=None, 6087 id=None, 6088 name=None, 6089 port=None, 6090 secret_store_id=None, 6091 tags=None, 6092 token=None, 6093 ): 6094 self.egress_filter = egress_filter if egress_filter is not None else '' 6095 ''' 6096 A filter applied to the routing logic to pin datasource to nodes. 6097 ''' 6098 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 6099 ''' 6100 The path used to check the health of your connection. Defaults to `default`. 6101 ''' 6102 self.healthy = healthy if healthy is not None else False 6103 ''' 6104 True if the datasource is reachable and the credentials are valid. 6105 ''' 6106 self.hostname = hostname if hostname is not None else '' 6107 ''' 6108 6109 ''' 6110 self.id = id if id is not None else '' 6111 ''' 6112 Unique identifier of the Resource. 6113 ''' 6114 self.name = name if name is not None else '' 6115 ''' 6116 Unique human-readable name of the Resource. 6117 ''' 6118 self.port = port if port is not None else 0 6119 ''' 6120 6121 ''' 6122 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 6123 ''' 6124 ID of the secret store containing credentials for this resource, if any. 6125 ''' 6126 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 6127 ''' 6128 Tags is a map of key, value pairs. 6129 ''' 6130 self.token = token if token is not None else '' 6131 ''' 6132 6133 ''' 6134 6135 def __repr__(self): 6136 return '<sdm.KubernetesServiceAccount ' + \ 6137 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 6138 'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\ 6139 'healthy: ' + repr(self.healthy) + ' ' +\ 6140 'hostname: ' + repr(self.hostname) + ' ' +\ 6141 'id: ' + repr(self.id) + ' ' +\ 6142 'name: ' + repr(self.name) + ' ' +\ 6143 'port: ' + repr(self.port) + ' ' +\ 6144 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 6145 'tags: ' + repr(self.tags) + ' ' +\ 6146 'token: ' + repr(self.token) + ' ' +\ 6147 '>' 6148 6149 def to_dict(self): 6150 return { 6151 'egress_filter': self.egress_filter, 6152 'healthcheck_namespace': self.healthcheck_namespace, 6153 'healthy': self.healthy, 6154 'hostname': self.hostname, 6155 'id': self.id, 6156 'name': self.name, 6157 'port': self.port, 6158 'secret_store_id': self.secret_store_id, 6159 'tags': self.tags, 6160 'token': self.token, 6161 } 6162 6163 @classmethod 6164 def from_dict(cls, d): 6165 return cls( 6166 egress_filter=d.get('egress_filter'), 6167 healthcheck_namespace=d.get('healthcheck_namespace'), 6168 healthy=d.get('healthy'), 6169 hostname=d.get('hostname'), 6170 id=d.get('id'), 6171 name=d.get('name'), 6172 port=d.get('port'), 6173 secret_store_id=d.get('secret_store_id'), 6174 tags=d.get('tags'), 6175 token=d.get('token'), 6176 ) 6177 6178 6179class KubernetesServiceAccountUserImpersonation: 6180 ''' 6181 6182 ''' 6183 __slots__ = [ 6184 'egress_filter', 6185 'healthcheck_namespace', 6186 'healthy', 6187 'hostname', 6188 'id', 6189 'name', 6190 'port', 6191 'secret_store_id', 6192 'tags', 6193 'token', 6194 ] 6195 6196 def __init__( 6197 self, 6198 egress_filter=None, 6199 healthcheck_namespace=None, 6200 healthy=None, 6201 hostname=None, 6202 id=None, 6203 name=None, 6204 port=None, 6205 secret_store_id=None, 6206 tags=None, 6207 token=None, 6208 ): 6209 self.egress_filter = egress_filter if egress_filter is not None else '' 6210 ''' 6211 A filter applied to the routing logic to pin datasource to nodes. 6212 ''' 6213 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 6214 ''' 6215 The path used to check the health of your connection. Defaults to `default`. 6216 ''' 6217 self.healthy = healthy if healthy is not None else False 6218 ''' 6219 True if the datasource is reachable and the credentials are valid. 6220 ''' 6221 self.hostname = hostname if hostname is not None else '' 6222 ''' 6223 6224 ''' 6225 self.id = id if id is not None else '' 6226 ''' 6227 Unique identifier of the Resource. 6228 ''' 6229 self.name = name if name is not None else '' 6230 ''' 6231 Unique human-readable name of the Resource. 6232 ''' 6233 self.port = port if port is not None else 0 6234 ''' 6235 6236 ''' 6237 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 6238 ''' 6239 ID of the secret store containing credentials for this resource, if any. 6240 ''' 6241 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 6242 ''' 6243 Tags is a map of key, value pairs. 6244 ''' 6245 self.token = token if token is not None else '' 6246 ''' 6247 6248 ''' 6249 6250 def __repr__(self): 6251 return '<sdm.KubernetesServiceAccountUserImpersonation ' + \ 6252 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 6253 'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\ 6254 'healthy: ' + repr(self.healthy) + ' ' +\ 6255 'hostname: ' + repr(self.hostname) + ' ' +\ 6256 'id: ' + repr(self.id) + ' ' +\ 6257 'name: ' + repr(self.name) + ' ' +\ 6258 'port: ' + repr(self.port) + ' ' +\ 6259 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 6260 'tags: ' + repr(self.tags) + ' ' +\ 6261 'token: ' + repr(self.token) + ' ' +\ 6262 '>' 6263 6264 def to_dict(self): 6265 return { 6266 'egress_filter': self.egress_filter, 6267 'healthcheck_namespace': self.healthcheck_namespace, 6268 'healthy': self.healthy, 6269 'hostname': self.hostname, 6270 'id': self.id, 6271 'name': self.name, 6272 'port': self.port, 6273 'secret_store_id': self.secret_store_id, 6274 'tags': self.tags, 6275 'token': self.token, 6276 } 6277 6278 @classmethod 6279 def from_dict(cls, d): 6280 return cls( 6281 egress_filter=d.get('egress_filter'), 6282 healthcheck_namespace=d.get('healthcheck_namespace'), 6283 healthy=d.get('healthy'), 6284 hostname=d.get('hostname'), 6285 id=d.get('id'), 6286 name=d.get('name'), 6287 port=d.get('port'), 6288 secret_store_id=d.get('secret_store_id'), 6289 tags=d.get('tags'), 6290 token=d.get('token'), 6291 ) 6292 6293 6294class KubernetesUserImpersonation: 6295 ''' 6296 6297 ''' 6298 __slots__ = [ 6299 'certificate_authority', 6300 'client_certificate', 6301 'client_key', 6302 'egress_filter', 6303 'healthcheck_namespace', 6304 'healthy', 6305 'hostname', 6306 'id', 6307 'name', 6308 'port', 6309 'secret_store_id', 6310 'tags', 6311 ] 6312 6313 def __init__( 6314 self, 6315 certificate_authority=None, 6316 client_certificate=None, 6317 client_key=None, 6318 egress_filter=None, 6319 healthcheck_namespace=None, 6320 healthy=None, 6321 hostname=None, 6322 id=None, 6323 name=None, 6324 port=None, 6325 secret_store_id=None, 6326 tags=None, 6327 ): 6328 self.certificate_authority = certificate_authority if certificate_authority is not None else '' 6329 ''' 6330 6331 ''' 6332 self.client_certificate = client_certificate if client_certificate is not None else '' 6333 ''' 6334 6335 ''' 6336 self.client_key = client_key if client_key is not None else '' 6337 ''' 6338 6339 ''' 6340 self.egress_filter = egress_filter if egress_filter is not None else '' 6341 ''' 6342 A filter applied to the routing logic to pin datasource to nodes. 6343 ''' 6344 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 6345 ''' 6346 The path used to check the health of your connection. Defaults to `default`. 6347 ''' 6348 self.healthy = healthy if healthy is not None else False 6349 ''' 6350 True if the datasource is reachable and the credentials are valid. 6351 ''' 6352 self.hostname = hostname if hostname is not None else '' 6353 ''' 6354 6355 ''' 6356 self.id = id if id is not None else '' 6357 ''' 6358 Unique identifier of the Resource. 6359 ''' 6360 self.name = name if name is not None else '' 6361 ''' 6362 Unique human-readable name of the Resource. 6363 ''' 6364 self.port = port if port is not None else 0 6365 ''' 6366 6367 ''' 6368 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 6369 ''' 6370 ID of the secret store containing credentials for this resource, if any. 6371 ''' 6372 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 6373 ''' 6374 Tags is a map of key, value pairs. 6375 ''' 6376 6377 def __repr__(self): 6378 return '<sdm.KubernetesUserImpersonation ' + \ 6379 'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\ 6380 'client_certificate: ' + repr(self.client_certificate) + ' ' +\ 6381 'client_key: ' + repr(self.client_key) + ' ' +\ 6382 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 6383 'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\ 6384 'healthy: ' + repr(self.healthy) + ' ' +\ 6385 'hostname: ' + repr(self.hostname) + ' ' +\ 6386 'id: ' + repr(self.id) + ' ' +\ 6387 'name: ' + repr(self.name) + ' ' +\ 6388 'port: ' + repr(self.port) + ' ' +\ 6389 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 6390 'tags: ' + repr(self.tags) + ' ' +\ 6391 '>' 6392 6393 def to_dict(self): 6394 return { 6395 'certificate_authority': self.certificate_authority, 6396 'client_certificate': self.client_certificate, 6397 'client_key': self.client_key, 6398 'egress_filter': self.egress_filter, 6399 'healthcheck_namespace': self.healthcheck_namespace, 6400 'healthy': self.healthy, 6401 'hostname': self.hostname, 6402 'id': self.id, 6403 'name': self.name, 6404 'port': self.port, 6405 'secret_store_id': self.secret_store_id, 6406 'tags': self.tags, 6407 } 6408 6409 @classmethod 6410 def from_dict(cls, d): 6411 return cls( 6412 certificate_authority=d.get('certificate_authority'), 6413 client_certificate=d.get('client_certificate'), 6414 client_key=d.get('client_key'), 6415 egress_filter=d.get('egress_filter'), 6416 healthcheck_namespace=d.get('healthcheck_namespace'), 6417 healthy=d.get('healthy'), 6418 hostname=d.get('hostname'), 6419 id=d.get('id'), 6420 name=d.get('name'), 6421 port=d.get('port'), 6422 secret_store_id=d.get('secret_store_id'), 6423 tags=d.get('tags'), 6424 ) 6425 6426 6427class MTLSMysql: 6428 ''' 6429 6430 ''' 6431 __slots__ = [ 6432 'certificate_authority', 6433 'client_certificate', 6434 'client_key', 6435 'database', 6436 'egress_filter', 6437 'healthy', 6438 'hostname', 6439 'id', 6440 'name', 6441 'password', 6442 'port', 6443 'port_override', 6444 'secret_store_id', 6445 'server_name', 6446 'tags', 6447 'username', 6448 ] 6449 6450 def __init__( 6451 self, 6452 certificate_authority=None, 6453 client_certificate=None, 6454 client_key=None, 6455 database=None, 6456 egress_filter=None, 6457 healthy=None, 6458 hostname=None, 6459 id=None, 6460 name=None, 6461 password=None, 6462 port=None, 6463 port_override=None, 6464 secret_store_id=None, 6465 server_name=None, 6466 tags=None, 6467 username=None, 6468 ): 6469 self.certificate_authority = certificate_authority if certificate_authority is not None else '' 6470 ''' 6471 6472 ''' 6473 self.client_certificate = client_certificate if client_certificate is not None else '' 6474 ''' 6475 6476 ''' 6477 self.client_key = client_key if client_key is not None else '' 6478 ''' 6479 6480 ''' 6481 self.database = database if database is not None else '' 6482 ''' 6483 6484 ''' 6485 self.egress_filter = egress_filter if egress_filter is not None else '' 6486 ''' 6487 A filter applied to the routing logic to pin datasource to nodes. 6488 ''' 6489 self.healthy = healthy if healthy is not None else False 6490 ''' 6491 True if the datasource is reachable and the credentials are valid. 6492 ''' 6493 self.hostname = hostname if hostname is not None else '' 6494 ''' 6495 6496 ''' 6497 self.id = id if id is not None else '' 6498 ''' 6499 Unique identifier of the Resource. 6500 ''' 6501 self.name = name if name is not None else '' 6502 ''' 6503 Unique human-readable name of the Resource. 6504 ''' 6505 self.password = password if password is not None else '' 6506 ''' 6507 6508 ''' 6509 self.port = port if port is not None else 0 6510 ''' 6511 6512 ''' 6513 self.port_override = port_override if port_override is not None else 0 6514 ''' 6515 6516 ''' 6517 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 6518 ''' 6519 ID of the secret store containing credentials for this resource, if any. 6520 ''' 6521 self.server_name = server_name if server_name is not None else '' 6522 ''' 6523 6524 ''' 6525 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 6526 ''' 6527 Tags is a map of key, value pairs. 6528 ''' 6529 self.username = username if username is not None else '' 6530 ''' 6531 6532 ''' 6533 6534 def __repr__(self): 6535 return '<sdm.MTLSMysql ' + \ 6536 'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\ 6537 'client_certificate: ' + repr(self.client_certificate) + ' ' +\ 6538 'client_key: ' + repr(self.client_key) + ' ' +\ 6539 'database: ' + repr(self.database) + ' ' +\ 6540 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 6541 'healthy: ' + repr(self.healthy) + ' ' +\ 6542 'hostname: ' + repr(self.hostname) + ' ' +\ 6543 'id: ' + repr(self.id) + ' ' +\ 6544 'name: ' + repr(self.name) + ' ' +\ 6545 'password: ' + repr(self.password) + ' ' +\ 6546 'port: ' + repr(self.port) + ' ' +\ 6547 'port_override: ' + repr(self.port_override) + ' ' +\ 6548 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 6549 'server_name: ' + repr(self.server_name) + ' ' +\ 6550 'tags: ' + repr(self.tags) + ' ' +\ 6551 'username: ' + repr(self.username) + ' ' +\ 6552 '>' 6553 6554 def to_dict(self): 6555 return { 6556 'certificate_authority': self.certificate_authority, 6557 'client_certificate': self.client_certificate, 6558 'client_key': self.client_key, 6559 'database': self.database, 6560 'egress_filter': self.egress_filter, 6561 'healthy': self.healthy, 6562 'hostname': self.hostname, 6563 'id': self.id, 6564 'name': self.name, 6565 'password': self.password, 6566 'port': self.port, 6567 'port_override': self.port_override, 6568 'secret_store_id': self.secret_store_id, 6569 'server_name': self.server_name, 6570 'tags': self.tags, 6571 'username': self.username, 6572 } 6573 6574 @classmethod 6575 def from_dict(cls, d): 6576 return cls( 6577 certificate_authority=d.get('certificate_authority'), 6578 client_certificate=d.get('client_certificate'), 6579 client_key=d.get('client_key'), 6580 database=d.get('database'), 6581 egress_filter=d.get('egress_filter'), 6582 healthy=d.get('healthy'), 6583 hostname=d.get('hostname'), 6584 id=d.get('id'), 6585 name=d.get('name'), 6586 password=d.get('password'), 6587 port=d.get('port'), 6588 port_override=d.get('port_override'), 6589 secret_store_id=d.get('secret_store_id'), 6590 server_name=d.get('server_name'), 6591 tags=d.get('tags'), 6592 username=d.get('username'), 6593 ) 6594 6595 6596class MTLSPostgres: 6597 ''' 6598 6599 ''' 6600 __slots__ = [ 6601 'certificate_authority', 6602 'client_certificate', 6603 'client_key', 6604 'database', 6605 'egress_filter', 6606 'healthy', 6607 'hostname', 6608 'id', 6609 'name', 6610 'override_database', 6611 'password', 6612 'port', 6613 'port_override', 6614 'secret_store_id', 6615 'server_name', 6616 'tags', 6617 'username', 6618 ] 6619 6620 def __init__( 6621 self, 6622 certificate_authority=None, 6623 client_certificate=None, 6624 client_key=None, 6625 database=None, 6626 egress_filter=None, 6627 healthy=None, 6628 hostname=None, 6629 id=None, 6630 name=None, 6631 override_database=None, 6632 password=None, 6633 port=None, 6634 port_override=None, 6635 secret_store_id=None, 6636 server_name=None, 6637 tags=None, 6638 username=None, 6639 ): 6640 self.certificate_authority = certificate_authority if certificate_authority is not None else '' 6641 ''' 6642 6643 ''' 6644 self.client_certificate = client_certificate if client_certificate is not None else '' 6645 ''' 6646 6647 ''' 6648 self.client_key = client_key if client_key is not None else '' 6649 ''' 6650 6651 ''' 6652 self.database = database if database is not None else '' 6653 ''' 6654 6655 ''' 6656 self.egress_filter = egress_filter if egress_filter is not None else '' 6657 ''' 6658 A filter applied to the routing logic to pin datasource to nodes. 6659 ''' 6660 self.healthy = healthy if healthy is not None else False 6661 ''' 6662 True if the datasource is reachable and the credentials are valid. 6663 ''' 6664 self.hostname = hostname if hostname is not None else '' 6665 ''' 6666 6667 ''' 6668 self.id = id if id is not None else '' 6669 ''' 6670 Unique identifier of the Resource. 6671 ''' 6672 self.name = name if name is not None else '' 6673 ''' 6674 Unique human-readable name of the Resource. 6675 ''' 6676 self.override_database = override_database if override_database is not None else False 6677 ''' 6678 6679 ''' 6680 self.password = password if password is not None else '' 6681 ''' 6682 6683 ''' 6684 self.port = port if port is not None else 0 6685 ''' 6686 6687 ''' 6688 self.port_override = port_override if port_override is not None else 0 6689 ''' 6690 6691 ''' 6692 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 6693 ''' 6694 ID of the secret store containing credentials for this resource, if any. 6695 ''' 6696 self.server_name = server_name if server_name is not None else '' 6697 ''' 6698 6699 ''' 6700 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 6701 ''' 6702 Tags is a map of key, value pairs. 6703 ''' 6704 self.username = username if username is not None else '' 6705 ''' 6706 6707 ''' 6708 6709 def __repr__(self): 6710 return '<sdm.MTLSPostgres ' + \ 6711 'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\ 6712 'client_certificate: ' + repr(self.client_certificate) + ' ' +\ 6713 'client_key: ' + repr(self.client_key) + ' ' +\ 6714 'database: ' + repr(self.database) + ' ' +\ 6715 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 6716 'healthy: ' + repr(self.healthy) + ' ' +\ 6717 'hostname: ' + repr(self.hostname) + ' ' +\ 6718 'id: ' + repr(self.id) + ' ' +\ 6719 'name: ' + repr(self.name) + ' ' +\ 6720 'override_database: ' + repr(self.override_database) + ' ' +\ 6721 'password: ' + repr(self.password) + ' ' +\ 6722 'port: ' + repr(self.port) + ' ' +\ 6723 'port_override: ' + repr(self.port_override) + ' ' +\ 6724 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 6725 'server_name: ' + repr(self.server_name) + ' ' +\ 6726 'tags: ' + repr(self.tags) + ' ' +\ 6727 'username: ' + repr(self.username) + ' ' +\ 6728 '>' 6729 6730 def to_dict(self): 6731 return { 6732 'certificate_authority': self.certificate_authority, 6733 'client_certificate': self.client_certificate, 6734 'client_key': self.client_key, 6735 'database': self.database, 6736 'egress_filter': self.egress_filter, 6737 'healthy': self.healthy, 6738 'hostname': self.hostname, 6739 'id': self.id, 6740 'name': self.name, 6741 'override_database': self.override_database, 6742 'password': self.password, 6743 'port': self.port, 6744 'port_override': self.port_override, 6745 'secret_store_id': self.secret_store_id, 6746 'server_name': self.server_name, 6747 'tags': self.tags, 6748 'username': self.username, 6749 } 6750 6751 @classmethod 6752 def from_dict(cls, d): 6753 return cls( 6754 certificate_authority=d.get('certificate_authority'), 6755 client_certificate=d.get('client_certificate'), 6756 client_key=d.get('client_key'), 6757 database=d.get('database'), 6758 egress_filter=d.get('egress_filter'), 6759 healthy=d.get('healthy'), 6760 hostname=d.get('hostname'), 6761 id=d.get('id'), 6762 name=d.get('name'), 6763 override_database=d.get('override_database'), 6764 password=d.get('password'), 6765 port=d.get('port'), 6766 port_override=d.get('port_override'), 6767 secret_store_id=d.get('secret_store_id'), 6768 server_name=d.get('server_name'), 6769 tags=d.get('tags'), 6770 username=d.get('username'), 6771 ) 6772 6773 6774class Maria: 6775 ''' 6776 6777 ''' 6778 __slots__ = [ 6779 'database', 6780 'egress_filter', 6781 'healthy', 6782 'hostname', 6783 'id', 6784 'name', 6785 'password', 6786 'port', 6787 'port_override', 6788 'secret_store_id', 6789 'tags', 6790 'username', 6791 ] 6792 6793 def __init__( 6794 self, 6795 database=None, 6796 egress_filter=None, 6797 healthy=None, 6798 hostname=None, 6799 id=None, 6800 name=None, 6801 password=None, 6802 port=None, 6803 port_override=None, 6804 secret_store_id=None, 6805 tags=None, 6806 username=None, 6807 ): 6808 self.database = database if database is not None else '' 6809 ''' 6810 6811 ''' 6812 self.egress_filter = egress_filter if egress_filter is not None else '' 6813 ''' 6814 A filter applied to the routing logic to pin datasource to nodes. 6815 ''' 6816 self.healthy = healthy if healthy is not None else False 6817 ''' 6818 True if the datasource is reachable and the credentials are valid. 6819 ''' 6820 self.hostname = hostname if hostname is not None else '' 6821 ''' 6822 6823 ''' 6824 self.id = id if id is not None else '' 6825 ''' 6826 Unique identifier of the Resource. 6827 ''' 6828 self.name = name if name is not None else '' 6829 ''' 6830 Unique human-readable name of the Resource. 6831 ''' 6832 self.password = password if password is not None else '' 6833 ''' 6834 6835 ''' 6836 self.port = port if port is not None else 0 6837 ''' 6838 6839 ''' 6840 self.port_override = port_override if port_override is not None else 0 6841 ''' 6842 6843 ''' 6844 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 6845 ''' 6846 ID of the secret store containing credentials for this resource, if any. 6847 ''' 6848 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 6849 ''' 6850 Tags is a map of key, value pairs. 6851 ''' 6852 self.username = username if username is not None else '' 6853 ''' 6854 6855 ''' 6856 6857 def __repr__(self): 6858 return '<sdm.Maria ' + \ 6859 'database: ' + repr(self.database) + ' ' +\ 6860 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 6861 'healthy: ' + repr(self.healthy) + ' ' +\ 6862 'hostname: ' + repr(self.hostname) + ' ' +\ 6863 'id: ' + repr(self.id) + ' ' +\ 6864 'name: ' + repr(self.name) + ' ' +\ 6865 'password: ' + repr(self.password) + ' ' +\ 6866 'port: ' + repr(self.port) + ' ' +\ 6867 'port_override: ' + repr(self.port_override) + ' ' +\ 6868 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 6869 'tags: ' + repr(self.tags) + ' ' +\ 6870 'username: ' + repr(self.username) + ' ' +\ 6871 '>' 6872 6873 def to_dict(self): 6874 return { 6875 'database': self.database, 6876 'egress_filter': self.egress_filter, 6877 'healthy': self.healthy, 6878 'hostname': self.hostname, 6879 'id': self.id, 6880 'name': self.name, 6881 'password': self.password, 6882 'port': self.port, 6883 'port_override': self.port_override, 6884 'secret_store_id': self.secret_store_id, 6885 'tags': self.tags, 6886 'username': self.username, 6887 } 6888 6889 @classmethod 6890 def from_dict(cls, d): 6891 return cls( 6892 database=d.get('database'), 6893 egress_filter=d.get('egress_filter'), 6894 healthy=d.get('healthy'), 6895 hostname=d.get('hostname'), 6896 id=d.get('id'), 6897 name=d.get('name'), 6898 password=d.get('password'), 6899 port=d.get('port'), 6900 port_override=d.get('port_override'), 6901 secret_store_id=d.get('secret_store_id'), 6902 tags=d.get('tags'), 6903 username=d.get('username'), 6904 ) 6905 6906 6907class Memcached: 6908 ''' 6909 6910 ''' 6911 __slots__ = [ 6912 'egress_filter', 6913 'healthy', 6914 'hostname', 6915 'id', 6916 'name', 6917 'port', 6918 'port_override', 6919 'secret_store_id', 6920 'tags', 6921 ] 6922 6923 def __init__( 6924 self, 6925 egress_filter=None, 6926 healthy=None, 6927 hostname=None, 6928 id=None, 6929 name=None, 6930 port=None, 6931 port_override=None, 6932 secret_store_id=None, 6933 tags=None, 6934 ): 6935 self.egress_filter = egress_filter if egress_filter is not None else '' 6936 ''' 6937 A filter applied to the routing logic to pin datasource to nodes. 6938 ''' 6939 self.healthy = healthy if healthy is not None else False 6940 ''' 6941 True if the datasource is reachable and the credentials are valid. 6942 ''' 6943 self.hostname = hostname if hostname is not None else '' 6944 ''' 6945 6946 ''' 6947 self.id = id if id is not None else '' 6948 ''' 6949 Unique identifier of the Resource. 6950 ''' 6951 self.name = name if name is not None else '' 6952 ''' 6953 Unique human-readable name of the Resource. 6954 ''' 6955 self.port = port if port is not None else 0 6956 ''' 6957 6958 ''' 6959 self.port_override = port_override if port_override is not None else 0 6960 ''' 6961 6962 ''' 6963 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 6964 ''' 6965 ID of the secret store containing credentials for this resource, if any. 6966 ''' 6967 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 6968 ''' 6969 Tags is a map of key, value pairs. 6970 ''' 6971 6972 def __repr__(self): 6973 return '<sdm.Memcached ' + \ 6974 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 6975 'healthy: ' + repr(self.healthy) + ' ' +\ 6976 'hostname: ' + repr(self.hostname) + ' ' +\ 6977 'id: ' + repr(self.id) + ' ' +\ 6978 'name: ' + repr(self.name) + ' ' +\ 6979 'port: ' + repr(self.port) + ' ' +\ 6980 'port_override: ' + repr(self.port_override) + ' ' +\ 6981 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 6982 'tags: ' + repr(self.tags) + ' ' +\ 6983 '>' 6984 6985 def to_dict(self): 6986 return { 6987 'egress_filter': self.egress_filter, 6988 'healthy': self.healthy, 6989 'hostname': self.hostname, 6990 'id': self.id, 6991 'name': self.name, 6992 'port': self.port, 6993 'port_override': self.port_override, 6994 'secret_store_id': self.secret_store_id, 6995 'tags': self.tags, 6996 } 6997 6998 @classmethod 6999 def from_dict(cls, d): 7000 return cls( 7001 egress_filter=d.get('egress_filter'), 7002 healthy=d.get('healthy'), 7003 hostname=d.get('hostname'), 7004 id=d.get('id'), 7005 name=d.get('name'), 7006 port=d.get('port'), 7007 port_override=d.get('port_override'), 7008 secret_store_id=d.get('secret_store_id'), 7009 tags=d.get('tags'), 7010 ) 7011 7012 7013class Memsql: 7014 ''' 7015 7016 ''' 7017 __slots__ = [ 7018 'database', 7019 'egress_filter', 7020 'healthy', 7021 'hostname', 7022 'id', 7023 'name', 7024 'password', 7025 'port', 7026 'port_override', 7027 'secret_store_id', 7028 'tags', 7029 'username', 7030 ] 7031 7032 def __init__( 7033 self, 7034 database=None, 7035 egress_filter=None, 7036 healthy=None, 7037 hostname=None, 7038 id=None, 7039 name=None, 7040 password=None, 7041 port=None, 7042 port_override=None, 7043 secret_store_id=None, 7044 tags=None, 7045 username=None, 7046 ): 7047 self.database = database if database is not None else '' 7048 ''' 7049 7050 ''' 7051 self.egress_filter = egress_filter if egress_filter is not None else '' 7052 ''' 7053 A filter applied to the routing logic to pin datasource to nodes. 7054 ''' 7055 self.healthy = healthy if healthy is not None else False 7056 ''' 7057 True if the datasource is reachable and the credentials are valid. 7058 ''' 7059 self.hostname = hostname if hostname is not None else '' 7060 ''' 7061 7062 ''' 7063 self.id = id if id is not None else '' 7064 ''' 7065 Unique identifier of the Resource. 7066 ''' 7067 self.name = name if name is not None else '' 7068 ''' 7069 Unique human-readable name of the Resource. 7070 ''' 7071 self.password = password if password is not None else '' 7072 ''' 7073 7074 ''' 7075 self.port = port if port is not None else 0 7076 ''' 7077 7078 ''' 7079 self.port_override = port_override if port_override is not None else 0 7080 ''' 7081 7082 ''' 7083 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 7084 ''' 7085 ID of the secret store containing credentials for this resource, if any. 7086 ''' 7087 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 7088 ''' 7089 Tags is a map of key, value pairs. 7090 ''' 7091 self.username = username if username is not None else '' 7092 ''' 7093 7094 ''' 7095 7096 def __repr__(self): 7097 return '<sdm.Memsql ' + \ 7098 'database: ' + repr(self.database) + ' ' +\ 7099 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 7100 'healthy: ' + repr(self.healthy) + ' ' +\ 7101 'hostname: ' + repr(self.hostname) + ' ' +\ 7102 'id: ' + repr(self.id) + ' ' +\ 7103 'name: ' + repr(self.name) + ' ' +\ 7104 'password: ' + repr(self.password) + ' ' +\ 7105 'port: ' + repr(self.port) + ' ' +\ 7106 'port_override: ' + repr(self.port_override) + ' ' +\ 7107 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 7108 'tags: ' + repr(self.tags) + ' ' +\ 7109 'username: ' + repr(self.username) + ' ' +\ 7110 '>' 7111 7112 def to_dict(self): 7113 return { 7114 'database': self.database, 7115 'egress_filter': self.egress_filter, 7116 'healthy': self.healthy, 7117 'hostname': self.hostname, 7118 'id': self.id, 7119 'name': self.name, 7120 'password': self.password, 7121 'port': self.port, 7122 'port_override': self.port_override, 7123 'secret_store_id': self.secret_store_id, 7124 'tags': self.tags, 7125 'username': self.username, 7126 } 7127 7128 @classmethod 7129 def from_dict(cls, d): 7130 return cls( 7131 database=d.get('database'), 7132 egress_filter=d.get('egress_filter'), 7133 healthy=d.get('healthy'), 7134 hostname=d.get('hostname'), 7135 id=d.get('id'), 7136 name=d.get('name'), 7137 password=d.get('password'), 7138 port=d.get('port'), 7139 port_override=d.get('port_override'), 7140 secret_store_id=d.get('secret_store_id'), 7141 tags=d.get('tags'), 7142 username=d.get('username'), 7143 ) 7144 7145 7146class MongoHost: 7147 ''' 7148 7149 ''' 7150 __slots__ = [ 7151 'auth_database', 7152 'egress_filter', 7153 'healthy', 7154 'hostname', 7155 'id', 7156 'name', 7157 'password', 7158 'port', 7159 'port_override', 7160 'secret_store_id', 7161 'tags', 7162 'tls_required', 7163 'username', 7164 ] 7165 7166 def __init__( 7167 self, 7168 auth_database=None, 7169 egress_filter=None, 7170 healthy=None, 7171 hostname=None, 7172 id=None, 7173 name=None, 7174 password=None, 7175 port=None, 7176 port_override=None, 7177 secret_store_id=None, 7178 tags=None, 7179 tls_required=None, 7180 username=None, 7181 ): 7182 self.auth_database = auth_database if auth_database is not None else '' 7183 ''' 7184 7185 ''' 7186 self.egress_filter = egress_filter if egress_filter is not None else '' 7187 ''' 7188 A filter applied to the routing logic to pin datasource to nodes. 7189 ''' 7190 self.healthy = healthy if healthy is not None else False 7191 ''' 7192 True if the datasource is reachable and the credentials are valid. 7193 ''' 7194 self.hostname = hostname if hostname is not None else '' 7195 ''' 7196 7197 ''' 7198 self.id = id if id is not None else '' 7199 ''' 7200 Unique identifier of the Resource. 7201 ''' 7202 self.name = name if name is not None else '' 7203 ''' 7204 Unique human-readable name of the Resource. 7205 ''' 7206 self.password = password if password is not None else '' 7207 ''' 7208 7209 ''' 7210 self.port = port if port is not None else 0 7211 ''' 7212 7213 ''' 7214 self.port_override = port_override if port_override is not None else 0 7215 ''' 7216 7217 ''' 7218 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 7219 ''' 7220 ID of the secret store containing credentials for this resource, if any. 7221 ''' 7222 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 7223 ''' 7224 Tags is a map of key, value pairs. 7225 ''' 7226 self.tls_required = tls_required if tls_required is not None else False 7227 ''' 7228 7229 ''' 7230 self.username = username if username is not None else '' 7231 ''' 7232 7233 ''' 7234 7235 def __repr__(self): 7236 return '<sdm.MongoHost ' + \ 7237 'auth_database: ' + repr(self.auth_database) + ' ' +\ 7238 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 7239 'healthy: ' + repr(self.healthy) + ' ' +\ 7240 'hostname: ' + repr(self.hostname) + ' ' +\ 7241 'id: ' + repr(self.id) + ' ' +\ 7242 'name: ' + repr(self.name) + ' ' +\ 7243 'password: ' + repr(self.password) + ' ' +\ 7244 'port: ' + repr(self.port) + ' ' +\ 7245 'port_override: ' + repr(self.port_override) + ' ' +\ 7246 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 7247 'tags: ' + repr(self.tags) + ' ' +\ 7248 'tls_required: ' + repr(self.tls_required) + ' ' +\ 7249 'username: ' + repr(self.username) + ' ' +\ 7250 '>' 7251 7252 def to_dict(self): 7253 return { 7254 'auth_database': self.auth_database, 7255 'egress_filter': self.egress_filter, 7256 'healthy': self.healthy, 7257 'hostname': self.hostname, 7258 'id': self.id, 7259 'name': self.name, 7260 'password': self.password, 7261 'port': self.port, 7262 'port_override': self.port_override, 7263 'secret_store_id': self.secret_store_id, 7264 'tags': self.tags, 7265 'tls_required': self.tls_required, 7266 'username': self.username, 7267 } 7268 7269 @classmethod 7270 def from_dict(cls, d): 7271 return cls( 7272 auth_database=d.get('auth_database'), 7273 egress_filter=d.get('egress_filter'), 7274 healthy=d.get('healthy'), 7275 hostname=d.get('hostname'), 7276 id=d.get('id'), 7277 name=d.get('name'), 7278 password=d.get('password'), 7279 port=d.get('port'), 7280 port_override=d.get('port_override'), 7281 secret_store_id=d.get('secret_store_id'), 7282 tags=d.get('tags'), 7283 tls_required=d.get('tls_required'), 7284 username=d.get('username'), 7285 ) 7286 7287 7288class MongoLegacyHost: 7289 ''' 7290 7291 ''' 7292 __slots__ = [ 7293 'auth_database', 7294 'egress_filter', 7295 'healthy', 7296 'hostname', 7297 'id', 7298 'name', 7299 'password', 7300 'port', 7301 'port_override', 7302 'replica_set', 7303 'secret_store_id', 7304 'tags', 7305 'tls_required', 7306 'username', 7307 ] 7308 7309 def __init__( 7310 self, 7311 auth_database=None, 7312 egress_filter=None, 7313 healthy=None, 7314 hostname=None, 7315 id=None, 7316 name=None, 7317 password=None, 7318 port=None, 7319 port_override=None, 7320 replica_set=None, 7321 secret_store_id=None, 7322 tags=None, 7323 tls_required=None, 7324 username=None, 7325 ): 7326 self.auth_database = auth_database if auth_database is not None else '' 7327 ''' 7328 7329 ''' 7330 self.egress_filter = egress_filter if egress_filter is not None else '' 7331 ''' 7332 A filter applied to the routing logic to pin datasource to nodes. 7333 ''' 7334 self.healthy = healthy if healthy is not None else False 7335 ''' 7336 True if the datasource is reachable and the credentials are valid. 7337 ''' 7338 self.hostname = hostname if hostname is not None else '' 7339 ''' 7340 7341 ''' 7342 self.id = id if id is not None else '' 7343 ''' 7344 Unique identifier of the Resource. 7345 ''' 7346 self.name = name if name is not None else '' 7347 ''' 7348 Unique human-readable name of the Resource. 7349 ''' 7350 self.password = password if password is not None else '' 7351 ''' 7352 7353 ''' 7354 self.port = port if port is not None else 0 7355 ''' 7356 7357 ''' 7358 self.port_override = port_override if port_override is not None else 0 7359 ''' 7360 7361 ''' 7362 self.replica_set = replica_set if replica_set is not None else '' 7363 ''' 7364 7365 ''' 7366 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 7367 ''' 7368 ID of the secret store containing credentials for this resource, if any. 7369 ''' 7370 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 7371 ''' 7372 Tags is a map of key, value pairs. 7373 ''' 7374 self.tls_required = tls_required if tls_required is not None else False 7375 ''' 7376 7377 ''' 7378 self.username = username if username is not None else '' 7379 ''' 7380 7381 ''' 7382 7383 def __repr__(self): 7384 return '<sdm.MongoLegacyHost ' + \ 7385 'auth_database: ' + repr(self.auth_database) + ' ' +\ 7386 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 7387 'healthy: ' + repr(self.healthy) + ' ' +\ 7388 'hostname: ' + repr(self.hostname) + ' ' +\ 7389 'id: ' + repr(self.id) + ' ' +\ 7390 'name: ' + repr(self.name) + ' ' +\ 7391 'password: ' + repr(self.password) + ' ' +\ 7392 'port: ' + repr(self.port) + ' ' +\ 7393 'port_override: ' + repr(self.port_override) + ' ' +\ 7394 'replica_set: ' + repr(self.replica_set) + ' ' +\ 7395 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 7396 'tags: ' + repr(self.tags) + ' ' +\ 7397 'tls_required: ' + repr(self.tls_required) + ' ' +\ 7398 'username: ' + repr(self.username) + ' ' +\ 7399 '>' 7400 7401 def to_dict(self): 7402 return { 7403 'auth_database': self.auth_database, 7404 'egress_filter': self.egress_filter, 7405 'healthy': self.healthy, 7406 'hostname': self.hostname, 7407 'id': self.id, 7408 'name': self.name, 7409 'password': self.password, 7410 'port': self.port, 7411 'port_override': self.port_override, 7412 'replica_set': self.replica_set, 7413 'secret_store_id': self.secret_store_id, 7414 'tags': self.tags, 7415 'tls_required': self.tls_required, 7416 'username': self.username, 7417 } 7418 7419 @classmethod 7420 def from_dict(cls, d): 7421 return cls( 7422 auth_database=d.get('auth_database'), 7423 egress_filter=d.get('egress_filter'), 7424 healthy=d.get('healthy'), 7425 hostname=d.get('hostname'), 7426 id=d.get('id'), 7427 name=d.get('name'), 7428 password=d.get('password'), 7429 port=d.get('port'), 7430 port_override=d.get('port_override'), 7431 replica_set=d.get('replica_set'), 7432 secret_store_id=d.get('secret_store_id'), 7433 tags=d.get('tags'), 7434 tls_required=d.get('tls_required'), 7435 username=d.get('username'), 7436 ) 7437 7438 7439class MongoLegacyReplicaset: 7440 ''' 7441 7442 ''' 7443 __slots__ = [ 7444 'auth_database', 7445 'connect_to_replica', 7446 'egress_filter', 7447 'healthy', 7448 'hostname', 7449 'id', 7450 'name', 7451 'password', 7452 'port', 7453 'port_override', 7454 'replica_set', 7455 'secret_store_id', 7456 'tags', 7457 'tls_required', 7458 'username', 7459 ] 7460 7461 def __init__( 7462 self, 7463 auth_database=None, 7464 connect_to_replica=None, 7465 egress_filter=None, 7466 healthy=None, 7467 hostname=None, 7468 id=None, 7469 name=None, 7470 password=None, 7471 port=None, 7472 port_override=None, 7473 replica_set=None, 7474 secret_store_id=None, 7475 tags=None, 7476 tls_required=None, 7477 username=None, 7478 ): 7479 self.auth_database = auth_database if auth_database is not None else '' 7480 ''' 7481 7482 ''' 7483 self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False 7484 ''' 7485 7486 ''' 7487 self.egress_filter = egress_filter if egress_filter is not None else '' 7488 ''' 7489 A filter applied to the routing logic to pin datasource to nodes. 7490 ''' 7491 self.healthy = healthy if healthy is not None else False 7492 ''' 7493 True if the datasource is reachable and the credentials are valid. 7494 ''' 7495 self.hostname = hostname if hostname is not None else '' 7496 ''' 7497 7498 ''' 7499 self.id = id if id is not None else '' 7500 ''' 7501 Unique identifier of the Resource. 7502 ''' 7503 self.name = name if name is not None else '' 7504 ''' 7505 Unique human-readable name of the Resource. 7506 ''' 7507 self.password = password if password is not None else '' 7508 ''' 7509 7510 ''' 7511 self.port = port if port is not None else 0 7512 ''' 7513 7514 ''' 7515 self.port_override = port_override if port_override is not None else 0 7516 ''' 7517 7518 ''' 7519 self.replica_set = replica_set if replica_set is not None else '' 7520 ''' 7521 7522 ''' 7523 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 7524 ''' 7525 ID of the secret store containing credentials for this resource, if any. 7526 ''' 7527 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 7528 ''' 7529 Tags is a map of key, value pairs. 7530 ''' 7531 self.tls_required = tls_required if tls_required is not None else False 7532 ''' 7533 7534 ''' 7535 self.username = username if username is not None else '' 7536 ''' 7537 7538 ''' 7539 7540 def __repr__(self): 7541 return '<sdm.MongoLegacyReplicaset ' + \ 7542 'auth_database: ' + repr(self.auth_database) + ' ' +\ 7543 'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\ 7544 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 7545 'healthy: ' + repr(self.healthy) + ' ' +\ 7546 'hostname: ' + repr(self.hostname) + ' ' +\ 7547 'id: ' + repr(self.id) + ' ' +\ 7548 'name: ' + repr(self.name) + ' ' +\ 7549 'password: ' + repr(self.password) + ' ' +\ 7550 'port: ' + repr(self.port) + ' ' +\ 7551 'port_override: ' + repr(self.port_override) + ' ' +\ 7552 'replica_set: ' + repr(self.replica_set) + ' ' +\ 7553 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 7554 'tags: ' + repr(self.tags) + ' ' +\ 7555 'tls_required: ' + repr(self.tls_required) + ' ' +\ 7556 'username: ' + repr(self.username) + ' ' +\ 7557 '>' 7558 7559 def to_dict(self): 7560 return { 7561 'auth_database': self.auth_database, 7562 'connect_to_replica': self.connect_to_replica, 7563 'egress_filter': self.egress_filter, 7564 'healthy': self.healthy, 7565 'hostname': self.hostname, 7566 'id': self.id, 7567 'name': self.name, 7568 'password': self.password, 7569 'port': self.port, 7570 'port_override': self.port_override, 7571 'replica_set': self.replica_set, 7572 'secret_store_id': self.secret_store_id, 7573 'tags': self.tags, 7574 'tls_required': self.tls_required, 7575 'username': self.username, 7576 } 7577 7578 @classmethod 7579 def from_dict(cls, d): 7580 return cls( 7581 auth_database=d.get('auth_database'), 7582 connect_to_replica=d.get('connect_to_replica'), 7583 egress_filter=d.get('egress_filter'), 7584 healthy=d.get('healthy'), 7585 hostname=d.get('hostname'), 7586 id=d.get('id'), 7587 name=d.get('name'), 7588 password=d.get('password'), 7589 port=d.get('port'), 7590 port_override=d.get('port_override'), 7591 replica_set=d.get('replica_set'), 7592 secret_store_id=d.get('secret_store_id'), 7593 tags=d.get('tags'), 7594 tls_required=d.get('tls_required'), 7595 username=d.get('username'), 7596 ) 7597 7598 7599class MongoReplicaSet: 7600 ''' 7601 7602 ''' 7603 __slots__ = [ 7604 'auth_database', 7605 'connect_to_replica', 7606 'egress_filter', 7607 'healthy', 7608 'hostname', 7609 'id', 7610 'name', 7611 'password', 7612 'port', 7613 'port_override', 7614 'replica_set', 7615 'secret_store_id', 7616 'tags', 7617 'tls_required', 7618 'username', 7619 ] 7620 7621 def __init__( 7622 self, 7623 auth_database=None, 7624 connect_to_replica=None, 7625 egress_filter=None, 7626 healthy=None, 7627 hostname=None, 7628 id=None, 7629 name=None, 7630 password=None, 7631 port=None, 7632 port_override=None, 7633 replica_set=None, 7634 secret_store_id=None, 7635 tags=None, 7636 tls_required=None, 7637 username=None, 7638 ): 7639 self.auth_database = auth_database if auth_database is not None else '' 7640 ''' 7641 7642 ''' 7643 self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False 7644 ''' 7645 7646 ''' 7647 self.egress_filter = egress_filter if egress_filter is not None else '' 7648 ''' 7649 A filter applied to the routing logic to pin datasource to nodes. 7650 ''' 7651 self.healthy = healthy if healthy is not None else False 7652 ''' 7653 True if the datasource is reachable and the credentials are valid. 7654 ''' 7655 self.hostname = hostname if hostname is not None else '' 7656 ''' 7657 7658 ''' 7659 self.id = id if id is not None else '' 7660 ''' 7661 Unique identifier of the Resource. 7662 ''' 7663 self.name = name if name is not None else '' 7664 ''' 7665 Unique human-readable name of the Resource. 7666 ''' 7667 self.password = password if password is not None else '' 7668 ''' 7669 7670 ''' 7671 self.port = port if port is not None else 0 7672 ''' 7673 7674 ''' 7675 self.port_override = port_override if port_override is not None else 0 7676 ''' 7677 7678 ''' 7679 self.replica_set = replica_set if replica_set is not None else '' 7680 ''' 7681 7682 ''' 7683 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 7684 ''' 7685 ID of the secret store containing credentials for this resource, if any. 7686 ''' 7687 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 7688 ''' 7689 Tags is a map of key, value pairs. 7690 ''' 7691 self.tls_required = tls_required if tls_required is not None else False 7692 ''' 7693 7694 ''' 7695 self.username = username if username is not None else '' 7696 ''' 7697 7698 ''' 7699 7700 def __repr__(self): 7701 return '<sdm.MongoReplicaSet ' + \ 7702 'auth_database: ' + repr(self.auth_database) + ' ' +\ 7703 'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\ 7704 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 7705 'healthy: ' + repr(self.healthy) + ' ' +\ 7706 'hostname: ' + repr(self.hostname) + ' ' +\ 7707 'id: ' + repr(self.id) + ' ' +\ 7708 'name: ' + repr(self.name) + ' ' +\ 7709 'password: ' + repr(self.password) + ' ' +\ 7710 'port: ' + repr(self.port) + ' ' +\ 7711 'port_override: ' + repr(self.port_override) + ' ' +\ 7712 'replica_set: ' + repr(self.replica_set) + ' ' +\ 7713 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 7714 'tags: ' + repr(self.tags) + ' ' +\ 7715 'tls_required: ' + repr(self.tls_required) + ' ' +\ 7716 'username: ' + repr(self.username) + ' ' +\ 7717 '>' 7718 7719 def to_dict(self): 7720 return { 7721 'auth_database': self.auth_database, 7722 'connect_to_replica': self.connect_to_replica, 7723 'egress_filter': self.egress_filter, 7724 'healthy': self.healthy, 7725 'hostname': self.hostname, 7726 'id': self.id, 7727 'name': self.name, 7728 'password': self.password, 7729 'port': self.port, 7730 'port_override': self.port_override, 7731 'replica_set': self.replica_set, 7732 'secret_store_id': self.secret_store_id, 7733 'tags': self.tags, 7734 'tls_required': self.tls_required, 7735 'username': self.username, 7736 } 7737 7738 @classmethod 7739 def from_dict(cls, d): 7740 return cls( 7741 auth_database=d.get('auth_database'), 7742 connect_to_replica=d.get('connect_to_replica'), 7743 egress_filter=d.get('egress_filter'), 7744 healthy=d.get('healthy'), 7745 hostname=d.get('hostname'), 7746 id=d.get('id'), 7747 name=d.get('name'), 7748 password=d.get('password'), 7749 port=d.get('port'), 7750 port_override=d.get('port_override'), 7751 replica_set=d.get('replica_set'), 7752 secret_store_id=d.get('secret_store_id'), 7753 tags=d.get('tags'), 7754 tls_required=d.get('tls_required'), 7755 username=d.get('username'), 7756 ) 7757 7758 7759class MongoShardedCluster: 7760 ''' 7761 7762 ''' 7763 __slots__ = [ 7764 'auth_database', 7765 'egress_filter', 7766 'healthy', 7767 'hostname', 7768 'id', 7769 'name', 7770 'password', 7771 'port_override', 7772 'secret_store_id', 7773 'tags', 7774 'tls_required', 7775 'username', 7776 ] 7777 7778 def __init__( 7779 self, 7780 auth_database=None, 7781 egress_filter=None, 7782 healthy=None, 7783 hostname=None, 7784 id=None, 7785 name=None, 7786 password=None, 7787 port_override=None, 7788 secret_store_id=None, 7789 tags=None, 7790 tls_required=None, 7791 username=None, 7792 ): 7793 self.auth_database = auth_database if auth_database is not None else '' 7794 ''' 7795 7796 ''' 7797 self.egress_filter = egress_filter if egress_filter is not None else '' 7798 ''' 7799 A filter applied to the routing logic to pin datasource to nodes. 7800 ''' 7801 self.healthy = healthy if healthy is not None else False 7802 ''' 7803 True if the datasource is reachable and the credentials are valid. 7804 ''' 7805 self.hostname = hostname if hostname is not None else '' 7806 ''' 7807 7808 ''' 7809 self.id = id if id is not None else '' 7810 ''' 7811 Unique identifier of the Resource. 7812 ''' 7813 self.name = name if name is not None else '' 7814 ''' 7815 Unique human-readable name of the Resource. 7816 ''' 7817 self.password = password if password is not None else '' 7818 ''' 7819 7820 ''' 7821 self.port_override = port_override if port_override is not None else 0 7822 ''' 7823 7824 ''' 7825 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 7826 ''' 7827 ID of the secret store containing credentials for this resource, if any. 7828 ''' 7829 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 7830 ''' 7831 Tags is a map of key, value pairs. 7832 ''' 7833 self.tls_required = tls_required if tls_required is not None else False 7834 ''' 7835 7836 ''' 7837 self.username = username if username is not None else '' 7838 ''' 7839 7840 ''' 7841 7842 def __repr__(self): 7843 return '<sdm.MongoShardedCluster ' + \ 7844 'auth_database: ' + repr(self.auth_database) + ' ' +\ 7845 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 7846 'healthy: ' + repr(self.healthy) + ' ' +\ 7847 'hostname: ' + repr(self.hostname) + ' ' +\ 7848 'id: ' + repr(self.id) + ' ' +\ 7849 'name: ' + repr(self.name) + ' ' +\ 7850 'password: ' + repr(self.password) + ' ' +\ 7851 'port_override: ' + repr(self.port_override) + ' ' +\ 7852 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 7853 'tags: ' + repr(self.tags) + ' ' +\ 7854 'tls_required: ' + repr(self.tls_required) + ' ' +\ 7855 'username: ' + repr(self.username) + ' ' +\ 7856 '>' 7857 7858 def to_dict(self): 7859 return { 7860 'auth_database': self.auth_database, 7861 'egress_filter': self.egress_filter, 7862 'healthy': self.healthy, 7863 'hostname': self.hostname, 7864 'id': self.id, 7865 'name': self.name, 7866 'password': self.password, 7867 'port_override': self.port_override, 7868 'secret_store_id': self.secret_store_id, 7869 'tags': self.tags, 7870 'tls_required': self.tls_required, 7871 'username': self.username, 7872 } 7873 7874 @classmethod 7875 def from_dict(cls, d): 7876 return cls( 7877 auth_database=d.get('auth_database'), 7878 egress_filter=d.get('egress_filter'), 7879 healthy=d.get('healthy'), 7880 hostname=d.get('hostname'), 7881 id=d.get('id'), 7882 name=d.get('name'), 7883 password=d.get('password'), 7884 port_override=d.get('port_override'), 7885 secret_store_id=d.get('secret_store_id'), 7886 tags=d.get('tags'), 7887 tls_required=d.get('tls_required'), 7888 username=d.get('username'), 7889 ) 7890 7891 7892class Mysql: 7893 ''' 7894 7895 ''' 7896 __slots__ = [ 7897 'database', 7898 'egress_filter', 7899 'healthy', 7900 'hostname', 7901 'id', 7902 'name', 7903 'password', 7904 'port', 7905 'port_override', 7906 'secret_store_id', 7907 'tags', 7908 'username', 7909 ] 7910 7911 def __init__( 7912 self, 7913 database=None, 7914 egress_filter=None, 7915 healthy=None, 7916 hostname=None, 7917 id=None, 7918 name=None, 7919 password=None, 7920 port=None, 7921 port_override=None, 7922 secret_store_id=None, 7923 tags=None, 7924 username=None, 7925 ): 7926 self.database = database if database is not None else '' 7927 ''' 7928 7929 ''' 7930 self.egress_filter = egress_filter if egress_filter is not None else '' 7931 ''' 7932 A filter applied to the routing logic to pin datasource to nodes. 7933 ''' 7934 self.healthy = healthy if healthy is not None else False 7935 ''' 7936 True if the datasource is reachable and the credentials are valid. 7937 ''' 7938 self.hostname = hostname if hostname is not None else '' 7939 ''' 7940 7941 ''' 7942 self.id = id if id is not None else '' 7943 ''' 7944 Unique identifier of the Resource. 7945 ''' 7946 self.name = name if name is not None else '' 7947 ''' 7948 Unique human-readable name of the Resource. 7949 ''' 7950 self.password = password if password is not None else '' 7951 ''' 7952 7953 ''' 7954 self.port = port if port is not None else 0 7955 ''' 7956 7957 ''' 7958 self.port_override = port_override if port_override is not None else 0 7959 ''' 7960 7961 ''' 7962 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 7963 ''' 7964 ID of the secret store containing credentials for this resource, if any. 7965 ''' 7966 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 7967 ''' 7968 Tags is a map of key, value pairs. 7969 ''' 7970 self.username = username if username is not None else '' 7971 ''' 7972 7973 ''' 7974 7975 def __repr__(self): 7976 return '<sdm.Mysql ' + \ 7977 'database: ' + repr(self.database) + ' ' +\ 7978 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 7979 'healthy: ' + repr(self.healthy) + ' ' +\ 7980 'hostname: ' + repr(self.hostname) + ' ' +\ 7981 'id: ' + repr(self.id) + ' ' +\ 7982 'name: ' + repr(self.name) + ' ' +\ 7983 'password: ' + repr(self.password) + ' ' +\ 7984 'port: ' + repr(self.port) + ' ' +\ 7985 'port_override: ' + repr(self.port_override) + ' ' +\ 7986 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 7987 'tags: ' + repr(self.tags) + ' ' +\ 7988 'username: ' + repr(self.username) + ' ' +\ 7989 '>' 7990 7991 def to_dict(self): 7992 return { 7993 'database': self.database, 7994 'egress_filter': self.egress_filter, 7995 'healthy': self.healthy, 7996 'hostname': self.hostname, 7997 'id': self.id, 7998 'name': self.name, 7999 'password': self.password, 8000 'port': self.port, 8001 'port_override': self.port_override, 8002 'secret_store_id': self.secret_store_id, 8003 'tags': self.tags, 8004 'username': self.username, 8005 } 8006 8007 @classmethod 8008 def from_dict(cls, d): 8009 return cls( 8010 database=d.get('database'), 8011 egress_filter=d.get('egress_filter'), 8012 healthy=d.get('healthy'), 8013 hostname=d.get('hostname'), 8014 id=d.get('id'), 8015 name=d.get('name'), 8016 password=d.get('password'), 8017 port=d.get('port'), 8018 port_override=d.get('port_override'), 8019 secret_store_id=d.get('secret_store_id'), 8020 tags=d.get('tags'), 8021 username=d.get('username'), 8022 ) 8023 8024 8025class Neptune: 8026 ''' 8027 8028 ''' 8029 __slots__ = [ 8030 'egress_filter', 8031 'endpoint', 8032 'healthy', 8033 'id', 8034 'name', 8035 'port', 8036 'port_override', 8037 'secret_store_id', 8038 'tags', 8039 ] 8040 8041 def __init__( 8042 self, 8043 egress_filter=None, 8044 endpoint=None, 8045 healthy=None, 8046 id=None, 8047 name=None, 8048 port=None, 8049 port_override=None, 8050 secret_store_id=None, 8051 tags=None, 8052 ): 8053 self.egress_filter = egress_filter if egress_filter is not None else '' 8054 ''' 8055 A filter applied to the routing logic to pin datasource to nodes. 8056 ''' 8057 self.endpoint = endpoint if endpoint is not None else '' 8058 ''' 8059 8060 ''' 8061 self.healthy = healthy if healthy is not None else False 8062 ''' 8063 True if the datasource is reachable and the credentials are valid. 8064 ''' 8065 self.id = id if id is not None else '' 8066 ''' 8067 Unique identifier of the Resource. 8068 ''' 8069 self.name = name if name is not None else '' 8070 ''' 8071 Unique human-readable name of the Resource. 8072 ''' 8073 self.port = port if port is not None else 0 8074 ''' 8075 8076 ''' 8077 self.port_override = port_override if port_override is not None else 0 8078 ''' 8079 8080 ''' 8081 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 8082 ''' 8083 ID of the secret store containing credentials for this resource, if any. 8084 ''' 8085 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 8086 ''' 8087 Tags is a map of key, value pairs. 8088 ''' 8089 8090 def __repr__(self): 8091 return '<sdm.Neptune ' + \ 8092 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 8093 'endpoint: ' + repr(self.endpoint) + ' ' +\ 8094 'healthy: ' + repr(self.healthy) + ' ' +\ 8095 'id: ' + repr(self.id) + ' ' +\ 8096 'name: ' + repr(self.name) + ' ' +\ 8097 'port: ' + repr(self.port) + ' ' +\ 8098 'port_override: ' + repr(self.port_override) + ' ' +\ 8099 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 8100 'tags: ' + repr(self.tags) + ' ' +\ 8101 '>' 8102 8103 def to_dict(self): 8104 return { 8105 'egress_filter': self.egress_filter, 8106 'endpoint': self.endpoint, 8107 'healthy': self.healthy, 8108 'id': self.id, 8109 'name': self.name, 8110 'port': self.port, 8111 'port_override': self.port_override, 8112 'secret_store_id': self.secret_store_id, 8113 'tags': self.tags, 8114 } 8115 8116 @classmethod 8117 def from_dict(cls, d): 8118 return cls( 8119 egress_filter=d.get('egress_filter'), 8120 endpoint=d.get('endpoint'), 8121 healthy=d.get('healthy'), 8122 id=d.get('id'), 8123 name=d.get('name'), 8124 port=d.get('port'), 8125 port_override=d.get('port_override'), 8126 secret_store_id=d.get('secret_store_id'), 8127 tags=d.get('tags'), 8128 ) 8129 8130 8131class NeptuneIAM: 8132 ''' 8133 8134 ''' 8135 __slots__ = [ 8136 'access_key', 8137 'egress_filter', 8138 'endpoint', 8139 'healthy', 8140 'id', 8141 'name', 8142 'port', 8143 'port_override', 8144 'region', 8145 'role_arn', 8146 'role_external_id', 8147 'secret_access_key', 8148 'secret_store_id', 8149 'tags', 8150 ] 8151 8152 def __init__( 8153 self, 8154 access_key=None, 8155 egress_filter=None, 8156 endpoint=None, 8157 healthy=None, 8158 id=None, 8159 name=None, 8160 port=None, 8161 port_override=None, 8162 region=None, 8163 role_arn=None, 8164 role_external_id=None, 8165 secret_access_key=None, 8166 secret_store_id=None, 8167 tags=None, 8168 ): 8169 self.access_key = access_key if access_key is not None else '' 8170 ''' 8171 8172 ''' 8173 self.egress_filter = egress_filter if egress_filter is not None else '' 8174 ''' 8175 A filter applied to the routing logic to pin datasource to nodes. 8176 ''' 8177 self.endpoint = endpoint if endpoint is not None else '' 8178 ''' 8179 8180 ''' 8181 self.healthy = healthy if healthy is not None else False 8182 ''' 8183 True if the datasource is reachable and the credentials are valid. 8184 ''' 8185 self.id = id if id is not None else '' 8186 ''' 8187 Unique identifier of the Resource. 8188 ''' 8189 self.name = name if name is not None else '' 8190 ''' 8191 Unique human-readable name of the Resource. 8192 ''' 8193 self.port = port if port is not None else 0 8194 ''' 8195 8196 ''' 8197 self.port_override = port_override if port_override is not None else 0 8198 ''' 8199 8200 ''' 8201 self.region = region if region is not None else '' 8202 ''' 8203 8204 ''' 8205 self.role_arn = role_arn if role_arn is not None else '' 8206 ''' 8207 8208 ''' 8209 self.role_external_id = role_external_id if role_external_id is not None else '' 8210 ''' 8211 8212 ''' 8213 self.secret_access_key = secret_access_key if secret_access_key is not None else '' 8214 ''' 8215 8216 ''' 8217 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 8218 ''' 8219 ID of the secret store containing credentials for this resource, if any. 8220 ''' 8221 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 8222 ''' 8223 Tags is a map of key, value pairs. 8224 ''' 8225 8226 def __repr__(self): 8227 return '<sdm.NeptuneIAM ' + \ 8228 'access_key: ' + repr(self.access_key) + ' ' +\ 8229 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 8230 'endpoint: ' + repr(self.endpoint) + ' ' +\ 8231 'healthy: ' + repr(self.healthy) + ' ' +\ 8232 'id: ' + repr(self.id) + ' ' +\ 8233 'name: ' + repr(self.name) + ' ' +\ 8234 'port: ' + repr(self.port) + ' ' +\ 8235 'port_override: ' + repr(self.port_override) + ' ' +\ 8236 'region: ' + repr(self.region) + ' ' +\ 8237 'role_arn: ' + repr(self.role_arn) + ' ' +\ 8238 'role_external_id: ' + repr(self.role_external_id) + ' ' +\ 8239 'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\ 8240 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 8241 'tags: ' + repr(self.tags) + ' ' +\ 8242 '>' 8243 8244 def to_dict(self): 8245 return { 8246 'access_key': self.access_key, 8247 'egress_filter': self.egress_filter, 8248 'endpoint': self.endpoint, 8249 'healthy': self.healthy, 8250 'id': self.id, 8251 'name': self.name, 8252 'port': self.port, 8253 'port_override': self.port_override, 8254 'region': self.region, 8255 'role_arn': self.role_arn, 8256 'role_external_id': self.role_external_id, 8257 'secret_access_key': self.secret_access_key, 8258 'secret_store_id': self.secret_store_id, 8259 'tags': self.tags, 8260 } 8261 8262 @classmethod 8263 def from_dict(cls, d): 8264 return cls( 8265 access_key=d.get('access_key'), 8266 egress_filter=d.get('egress_filter'), 8267 endpoint=d.get('endpoint'), 8268 healthy=d.get('healthy'), 8269 id=d.get('id'), 8270 name=d.get('name'), 8271 port=d.get('port'), 8272 port_override=d.get('port_override'), 8273 region=d.get('region'), 8274 role_arn=d.get('role_arn'), 8275 role_external_id=d.get('role_external_id'), 8276 secret_access_key=d.get('secret_access_key'), 8277 secret_store_id=d.get('secret_store_id'), 8278 tags=d.get('tags'), 8279 ) 8280 8281 8282class NodeCreateResponse: 8283 ''' 8284 NodeCreateResponse reports how the Nodes were created in the system. 8285 ''' 8286 __slots__ = [ 8287 'meta', 8288 'node', 8289 'rate_limit', 8290 'token', 8291 ] 8292 8293 def __init__( 8294 self, 8295 meta=None, 8296 node=None, 8297 rate_limit=None, 8298 token=None, 8299 ): 8300 self.meta = meta if meta is not None else None 8301 ''' 8302 Reserved for future use. 8303 ''' 8304 self.node = node if node is not None else None 8305 ''' 8306 The created Node. 8307 ''' 8308 self.rate_limit = rate_limit if rate_limit is not None else None 8309 ''' 8310 Rate limit information. 8311 ''' 8312 self.token = token if token is not None else '' 8313 ''' 8314 The auth token generated for the Node. The Node will use this token to 8315 authenticate with the strongDM API. 8316 ''' 8317 8318 def __repr__(self): 8319 return '<sdm.NodeCreateResponse ' + \ 8320 'meta: ' + repr(self.meta) + ' ' +\ 8321 'node: ' + repr(self.node) + ' ' +\ 8322 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 8323 'token: ' + repr(self.token) + ' ' +\ 8324 '>' 8325 8326 def to_dict(self): 8327 return { 8328 'meta': self.meta, 8329 'node': self.node, 8330 'rate_limit': self.rate_limit, 8331 'token': self.token, 8332 } 8333 8334 @classmethod 8335 def from_dict(cls, d): 8336 return cls( 8337 meta=d.get('meta'), 8338 node=d.get('node'), 8339 rate_limit=d.get('rate_limit'), 8340 token=d.get('token'), 8341 ) 8342 8343 8344class NodeDeleteResponse: 8345 ''' 8346 NodeDeleteResponse returns information about a Node that was deleted. 8347 ''' 8348 __slots__ = [ 8349 'meta', 8350 'rate_limit', 8351 ] 8352 8353 def __init__( 8354 self, 8355 meta=None, 8356 rate_limit=None, 8357 ): 8358 self.meta = meta if meta is not None else None 8359 ''' 8360 Reserved for future use. 8361 ''' 8362 self.rate_limit = rate_limit if rate_limit is not None else None 8363 ''' 8364 Rate limit information. 8365 ''' 8366 8367 def __repr__(self): 8368 return '<sdm.NodeDeleteResponse ' + \ 8369 'meta: ' + repr(self.meta) + ' ' +\ 8370 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 8371 '>' 8372 8373 def to_dict(self): 8374 return { 8375 'meta': self.meta, 8376 'rate_limit': self.rate_limit, 8377 } 8378 8379 @classmethod 8380 def from_dict(cls, d): 8381 return cls( 8382 meta=d.get('meta'), 8383 rate_limit=d.get('rate_limit'), 8384 ) 8385 8386 8387class NodeGetResponse: 8388 ''' 8389 NodeGetResponse returns a requested Node. 8390 ''' 8391 __slots__ = [ 8392 'meta', 8393 'node', 8394 'rate_limit', 8395 ] 8396 8397 def __init__( 8398 self, 8399 meta=None, 8400 node=None, 8401 rate_limit=None, 8402 ): 8403 self.meta = meta if meta is not None else None 8404 ''' 8405 Reserved for future use. 8406 ''' 8407 self.node = node if node is not None else None 8408 ''' 8409 The requested Node. 8410 ''' 8411 self.rate_limit = rate_limit if rate_limit is not None else None 8412 ''' 8413 Rate limit information. 8414 ''' 8415 8416 def __repr__(self): 8417 return '<sdm.NodeGetResponse ' + \ 8418 'meta: ' + repr(self.meta) + ' ' +\ 8419 'node: ' + repr(self.node) + ' ' +\ 8420 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 8421 '>' 8422 8423 def to_dict(self): 8424 return { 8425 'meta': self.meta, 8426 'node': self.node, 8427 'rate_limit': self.rate_limit, 8428 } 8429 8430 @classmethod 8431 def from_dict(cls, d): 8432 return cls( 8433 meta=d.get('meta'), 8434 node=d.get('node'), 8435 rate_limit=d.get('rate_limit'), 8436 ) 8437 8438 8439class NodeUpdateResponse: 8440 ''' 8441 NodeUpdateResponse returns the fields of a Node after it has been updated by 8442 a NodeUpdateRequest. 8443 ''' 8444 __slots__ = [ 8445 'meta', 8446 'node', 8447 'rate_limit', 8448 ] 8449 8450 def __init__( 8451 self, 8452 meta=None, 8453 node=None, 8454 rate_limit=None, 8455 ): 8456 self.meta = meta if meta is not None else None 8457 ''' 8458 Reserved for future use. 8459 ''' 8460 self.node = node if node is not None else None 8461 ''' 8462 The updated Node. 8463 ''' 8464 self.rate_limit = rate_limit if rate_limit is not None else None 8465 ''' 8466 Rate limit information. 8467 ''' 8468 8469 def __repr__(self): 8470 return '<sdm.NodeUpdateResponse ' + \ 8471 'meta: ' + repr(self.meta) + ' ' +\ 8472 'node: ' + repr(self.node) + ' ' +\ 8473 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 8474 '>' 8475 8476 def to_dict(self): 8477 return { 8478 'meta': self.meta, 8479 'node': self.node, 8480 'rate_limit': self.rate_limit, 8481 } 8482 8483 @classmethod 8484 def from_dict(cls, d): 8485 return cls( 8486 meta=d.get('meta'), 8487 node=d.get('node'), 8488 rate_limit=d.get('rate_limit'), 8489 ) 8490 8491 8492class Oracle: 8493 ''' 8494 8495 ''' 8496 __slots__ = [ 8497 'database', 8498 'egress_filter', 8499 'healthy', 8500 'hostname', 8501 'id', 8502 'name', 8503 'password', 8504 'port', 8505 'port_override', 8506 'secret_store_id', 8507 'tags', 8508 'tls_required', 8509 'username', 8510 ] 8511 8512 def __init__( 8513 self, 8514 database=None, 8515 egress_filter=None, 8516 healthy=None, 8517 hostname=None, 8518 id=None, 8519 name=None, 8520 password=None, 8521 port=None, 8522 port_override=None, 8523 secret_store_id=None, 8524 tags=None, 8525 tls_required=None, 8526 username=None, 8527 ): 8528 self.database = database if database is not None else '' 8529 ''' 8530 8531 ''' 8532 self.egress_filter = egress_filter if egress_filter is not None else '' 8533 ''' 8534 A filter applied to the routing logic to pin datasource to nodes. 8535 ''' 8536 self.healthy = healthy if healthy is not None else False 8537 ''' 8538 True if the datasource is reachable and the credentials are valid. 8539 ''' 8540 self.hostname = hostname if hostname is not None else '' 8541 ''' 8542 8543 ''' 8544 self.id = id if id is not None else '' 8545 ''' 8546 Unique identifier of the Resource. 8547 ''' 8548 self.name = name if name is not None else '' 8549 ''' 8550 Unique human-readable name of the Resource. 8551 ''' 8552 self.password = password if password is not None else '' 8553 ''' 8554 8555 ''' 8556 self.port = port if port is not None else 0 8557 ''' 8558 8559 ''' 8560 self.port_override = port_override if port_override is not None else 0 8561 ''' 8562 8563 ''' 8564 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 8565 ''' 8566 ID of the secret store containing credentials for this resource, if any. 8567 ''' 8568 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 8569 ''' 8570 Tags is a map of key, value pairs. 8571 ''' 8572 self.tls_required = tls_required if tls_required is not None else False 8573 ''' 8574 8575 ''' 8576 self.username = username if username is not None else '' 8577 ''' 8578 8579 ''' 8580 8581 def __repr__(self): 8582 return '<sdm.Oracle ' + \ 8583 'database: ' + repr(self.database) + ' ' +\ 8584 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 8585 'healthy: ' + repr(self.healthy) + ' ' +\ 8586 'hostname: ' + repr(self.hostname) + ' ' +\ 8587 'id: ' + repr(self.id) + ' ' +\ 8588 'name: ' + repr(self.name) + ' ' +\ 8589 'password: ' + repr(self.password) + ' ' +\ 8590 'port: ' + repr(self.port) + ' ' +\ 8591 'port_override: ' + repr(self.port_override) + ' ' +\ 8592 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 8593 'tags: ' + repr(self.tags) + ' ' +\ 8594 'tls_required: ' + repr(self.tls_required) + ' ' +\ 8595 'username: ' + repr(self.username) + ' ' +\ 8596 '>' 8597 8598 def to_dict(self): 8599 return { 8600 'database': self.database, 8601 'egress_filter': self.egress_filter, 8602 'healthy': self.healthy, 8603 'hostname': self.hostname, 8604 'id': self.id, 8605 'name': self.name, 8606 'password': self.password, 8607 'port': self.port, 8608 'port_override': self.port_override, 8609 'secret_store_id': self.secret_store_id, 8610 'tags': self.tags, 8611 'tls_required': self.tls_required, 8612 'username': self.username, 8613 } 8614 8615 @classmethod 8616 def from_dict(cls, d): 8617 return cls( 8618 database=d.get('database'), 8619 egress_filter=d.get('egress_filter'), 8620 healthy=d.get('healthy'), 8621 hostname=d.get('hostname'), 8622 id=d.get('id'), 8623 name=d.get('name'), 8624 password=d.get('password'), 8625 port=d.get('port'), 8626 port_override=d.get('port_override'), 8627 secret_store_id=d.get('secret_store_id'), 8628 tags=d.get('tags'), 8629 tls_required=d.get('tls_required'), 8630 username=d.get('username'), 8631 ) 8632 8633 8634class Postgres: 8635 ''' 8636 8637 ''' 8638 __slots__ = [ 8639 'database', 8640 'egress_filter', 8641 'healthy', 8642 'hostname', 8643 'id', 8644 'name', 8645 'override_database', 8646 'password', 8647 'port', 8648 'port_override', 8649 'secret_store_id', 8650 'tags', 8651 'username', 8652 ] 8653 8654 def __init__( 8655 self, 8656 database=None, 8657 egress_filter=None, 8658 healthy=None, 8659 hostname=None, 8660 id=None, 8661 name=None, 8662 override_database=None, 8663 password=None, 8664 port=None, 8665 port_override=None, 8666 secret_store_id=None, 8667 tags=None, 8668 username=None, 8669 ): 8670 self.database = database if database is not None else '' 8671 ''' 8672 8673 ''' 8674 self.egress_filter = egress_filter if egress_filter is not None else '' 8675 ''' 8676 A filter applied to the routing logic to pin datasource to nodes. 8677 ''' 8678 self.healthy = healthy if healthy is not None else False 8679 ''' 8680 True if the datasource is reachable and the credentials are valid. 8681 ''' 8682 self.hostname = hostname if hostname is not None else '' 8683 ''' 8684 8685 ''' 8686 self.id = id if id is not None else '' 8687 ''' 8688 Unique identifier of the Resource. 8689 ''' 8690 self.name = name if name is not None else '' 8691 ''' 8692 Unique human-readable name of the Resource. 8693 ''' 8694 self.override_database = override_database if override_database is not None else False 8695 ''' 8696 8697 ''' 8698 self.password = password if password is not None else '' 8699 ''' 8700 8701 ''' 8702 self.port = port if port is not None else 0 8703 ''' 8704 8705 ''' 8706 self.port_override = port_override if port_override is not None else 0 8707 ''' 8708 8709 ''' 8710 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 8711 ''' 8712 ID of the secret store containing credentials for this resource, if any. 8713 ''' 8714 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 8715 ''' 8716 Tags is a map of key, value pairs. 8717 ''' 8718 self.username = username if username is not None else '' 8719 ''' 8720 8721 ''' 8722 8723 def __repr__(self): 8724 return '<sdm.Postgres ' + \ 8725 'database: ' + repr(self.database) + ' ' +\ 8726 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 8727 'healthy: ' + repr(self.healthy) + ' ' +\ 8728 'hostname: ' + repr(self.hostname) + ' ' +\ 8729 'id: ' + repr(self.id) + ' ' +\ 8730 'name: ' + repr(self.name) + ' ' +\ 8731 'override_database: ' + repr(self.override_database) + ' ' +\ 8732 'password: ' + repr(self.password) + ' ' +\ 8733 'port: ' + repr(self.port) + ' ' +\ 8734 'port_override: ' + repr(self.port_override) + ' ' +\ 8735 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 8736 'tags: ' + repr(self.tags) + ' ' +\ 8737 'username: ' + repr(self.username) + ' ' +\ 8738 '>' 8739 8740 def to_dict(self): 8741 return { 8742 'database': self.database, 8743 'egress_filter': self.egress_filter, 8744 'healthy': self.healthy, 8745 'hostname': self.hostname, 8746 'id': self.id, 8747 'name': self.name, 8748 'override_database': self.override_database, 8749 'password': self.password, 8750 'port': self.port, 8751 'port_override': self.port_override, 8752 'secret_store_id': self.secret_store_id, 8753 'tags': self.tags, 8754 'username': self.username, 8755 } 8756 8757 @classmethod 8758 def from_dict(cls, d): 8759 return cls( 8760 database=d.get('database'), 8761 egress_filter=d.get('egress_filter'), 8762 healthy=d.get('healthy'), 8763 hostname=d.get('hostname'), 8764 id=d.get('id'), 8765 name=d.get('name'), 8766 override_database=d.get('override_database'), 8767 password=d.get('password'), 8768 port=d.get('port'), 8769 port_override=d.get('port_override'), 8770 secret_store_id=d.get('secret_store_id'), 8771 tags=d.get('tags'), 8772 username=d.get('username'), 8773 ) 8774 8775 8776class Presto: 8777 ''' 8778 8779 ''' 8780 __slots__ = [ 8781 'database', 8782 'egress_filter', 8783 'healthy', 8784 'hostname', 8785 'id', 8786 'name', 8787 'password', 8788 'port', 8789 'port_override', 8790 'secret_store_id', 8791 'tags', 8792 'tls_required', 8793 'username', 8794 ] 8795 8796 def __init__( 8797 self, 8798 database=None, 8799 egress_filter=None, 8800 healthy=None, 8801 hostname=None, 8802 id=None, 8803 name=None, 8804 password=None, 8805 port=None, 8806 port_override=None, 8807 secret_store_id=None, 8808 tags=None, 8809 tls_required=None, 8810 username=None, 8811 ): 8812 self.database = database if database is not None else '' 8813 ''' 8814 8815 ''' 8816 self.egress_filter = egress_filter if egress_filter is not None else '' 8817 ''' 8818 A filter applied to the routing logic to pin datasource to nodes. 8819 ''' 8820 self.healthy = healthy if healthy is not None else False 8821 ''' 8822 True if the datasource is reachable and the credentials are valid. 8823 ''' 8824 self.hostname = hostname if hostname is not None else '' 8825 ''' 8826 8827 ''' 8828 self.id = id if id is not None else '' 8829 ''' 8830 Unique identifier of the Resource. 8831 ''' 8832 self.name = name if name is not None else '' 8833 ''' 8834 Unique human-readable name of the Resource. 8835 ''' 8836 self.password = password if password is not None else '' 8837 ''' 8838 8839 ''' 8840 self.port = port if port is not None else 0 8841 ''' 8842 8843 ''' 8844 self.port_override = port_override if port_override is not None else 0 8845 ''' 8846 8847 ''' 8848 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 8849 ''' 8850 ID of the secret store containing credentials for this resource, if any. 8851 ''' 8852 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 8853 ''' 8854 Tags is a map of key, value pairs. 8855 ''' 8856 self.tls_required = tls_required if tls_required is not None else False 8857 ''' 8858 8859 ''' 8860 self.username = username if username is not None else '' 8861 ''' 8862 8863 ''' 8864 8865 def __repr__(self): 8866 return '<sdm.Presto ' + \ 8867 'database: ' + repr(self.database) + ' ' +\ 8868 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 8869 'healthy: ' + repr(self.healthy) + ' ' +\ 8870 'hostname: ' + repr(self.hostname) + ' ' +\ 8871 'id: ' + repr(self.id) + ' ' +\ 8872 'name: ' + repr(self.name) + ' ' +\ 8873 'password: ' + repr(self.password) + ' ' +\ 8874 'port: ' + repr(self.port) + ' ' +\ 8875 'port_override: ' + repr(self.port_override) + ' ' +\ 8876 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 8877 'tags: ' + repr(self.tags) + ' ' +\ 8878 'tls_required: ' + repr(self.tls_required) + ' ' +\ 8879 'username: ' + repr(self.username) + ' ' +\ 8880 '>' 8881 8882 def to_dict(self): 8883 return { 8884 'database': self.database, 8885 'egress_filter': self.egress_filter, 8886 'healthy': self.healthy, 8887 'hostname': self.hostname, 8888 'id': self.id, 8889 'name': self.name, 8890 'password': self.password, 8891 'port': self.port, 8892 'port_override': self.port_override, 8893 'secret_store_id': self.secret_store_id, 8894 'tags': self.tags, 8895 'tls_required': self.tls_required, 8896 'username': self.username, 8897 } 8898 8899 @classmethod 8900 def from_dict(cls, d): 8901 return cls( 8902 database=d.get('database'), 8903 egress_filter=d.get('egress_filter'), 8904 healthy=d.get('healthy'), 8905 hostname=d.get('hostname'), 8906 id=d.get('id'), 8907 name=d.get('name'), 8908 password=d.get('password'), 8909 port=d.get('port'), 8910 port_override=d.get('port_override'), 8911 secret_store_id=d.get('secret_store_id'), 8912 tags=d.get('tags'), 8913 tls_required=d.get('tls_required'), 8914 username=d.get('username'), 8915 ) 8916 8917 8918class RDP: 8919 ''' 8920 8921 ''' 8922 __slots__ = [ 8923 'downgrade_nla_connections', 8924 'egress_filter', 8925 'healthy', 8926 'hostname', 8927 'id', 8928 'name', 8929 'password', 8930 'port', 8931 'port_override', 8932 'secret_store_id', 8933 'tags', 8934 'username', 8935 ] 8936 8937 def __init__( 8938 self, 8939 downgrade_nla_connections=None, 8940 egress_filter=None, 8941 healthy=None, 8942 hostname=None, 8943 id=None, 8944 name=None, 8945 password=None, 8946 port=None, 8947 port_override=None, 8948 secret_store_id=None, 8949 tags=None, 8950 username=None, 8951 ): 8952 self.downgrade_nla_connections = downgrade_nla_connections if downgrade_nla_connections is not None else False 8953 ''' 8954 8955 ''' 8956 self.egress_filter = egress_filter if egress_filter is not None else '' 8957 ''' 8958 A filter applied to the routing logic to pin datasource to nodes. 8959 ''' 8960 self.healthy = healthy if healthy is not None else False 8961 ''' 8962 True if the datasource is reachable and the credentials are valid. 8963 ''' 8964 self.hostname = hostname if hostname is not None else '' 8965 ''' 8966 8967 ''' 8968 self.id = id if id is not None else '' 8969 ''' 8970 Unique identifier of the Resource. 8971 ''' 8972 self.name = name if name is not None else '' 8973 ''' 8974 Unique human-readable name of the Resource. 8975 ''' 8976 self.password = password if password is not None else '' 8977 ''' 8978 8979 ''' 8980 self.port = port if port is not None else 0 8981 ''' 8982 8983 ''' 8984 self.port_override = port_override if port_override is not None else 0 8985 ''' 8986 8987 ''' 8988 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 8989 ''' 8990 ID of the secret store containing credentials for this resource, if any. 8991 ''' 8992 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 8993 ''' 8994 Tags is a map of key, value pairs. 8995 ''' 8996 self.username = username if username is not None else '' 8997 ''' 8998 8999 ''' 9000 9001 def __repr__(self): 9002 return '<sdm.RDP ' + \ 9003 'downgrade_nla_connections: ' + repr(self.downgrade_nla_connections) + ' ' +\ 9004 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 9005 'healthy: ' + repr(self.healthy) + ' ' +\ 9006 'hostname: ' + repr(self.hostname) + ' ' +\ 9007 'id: ' + repr(self.id) + ' ' +\ 9008 'name: ' + repr(self.name) + ' ' +\ 9009 'password: ' + repr(self.password) + ' ' +\ 9010 'port: ' + repr(self.port) + ' ' +\ 9011 'port_override: ' + repr(self.port_override) + ' ' +\ 9012 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 9013 'tags: ' + repr(self.tags) + ' ' +\ 9014 'username: ' + repr(self.username) + ' ' +\ 9015 '>' 9016 9017 def to_dict(self): 9018 return { 9019 'downgrade_nla_connections': self.downgrade_nla_connections, 9020 'egress_filter': self.egress_filter, 9021 'healthy': self.healthy, 9022 'hostname': self.hostname, 9023 'id': self.id, 9024 'name': self.name, 9025 'password': self.password, 9026 'port': self.port, 9027 'port_override': self.port_override, 9028 'secret_store_id': self.secret_store_id, 9029 'tags': self.tags, 9030 'username': self.username, 9031 } 9032 9033 @classmethod 9034 def from_dict(cls, d): 9035 return cls( 9036 downgrade_nla_connections=d.get('downgrade_nla_connections'), 9037 egress_filter=d.get('egress_filter'), 9038 healthy=d.get('healthy'), 9039 hostname=d.get('hostname'), 9040 id=d.get('id'), 9041 name=d.get('name'), 9042 password=d.get('password'), 9043 port=d.get('port'), 9044 port_override=d.get('port_override'), 9045 secret_store_id=d.get('secret_store_id'), 9046 tags=d.get('tags'), 9047 username=d.get('username'), 9048 ) 9049 9050 9051class RabbitMQAMQP091: 9052 ''' 9053 9054 ''' 9055 __slots__ = [ 9056 'egress_filter', 9057 'healthy', 9058 'hostname', 9059 'id', 9060 'name', 9061 'password', 9062 'port', 9063 'port_override', 9064 'secret_store_id', 9065 'tags', 9066 'tls_required', 9067 'username', 9068 ] 9069 9070 def __init__( 9071 self, 9072 egress_filter=None, 9073 healthy=None, 9074 hostname=None, 9075 id=None, 9076 name=None, 9077 password=None, 9078 port=None, 9079 port_override=None, 9080 secret_store_id=None, 9081 tags=None, 9082 tls_required=None, 9083 username=None, 9084 ): 9085 self.egress_filter = egress_filter if egress_filter is not None else '' 9086 ''' 9087 A filter applied to the routing logic to pin datasource to nodes. 9088 ''' 9089 self.healthy = healthy if healthy is not None else False 9090 ''' 9091 True if the datasource is reachable and the credentials are valid. 9092 ''' 9093 self.hostname = hostname if hostname is not None else '' 9094 ''' 9095 9096 ''' 9097 self.id = id if id is not None else '' 9098 ''' 9099 Unique identifier of the Resource. 9100 ''' 9101 self.name = name if name is not None else '' 9102 ''' 9103 Unique human-readable name of the Resource. 9104 ''' 9105 self.password = password if password is not None else '' 9106 ''' 9107 9108 ''' 9109 self.port = port if port is not None else 0 9110 ''' 9111 9112 ''' 9113 self.port_override = port_override if port_override is not None else 0 9114 ''' 9115 9116 ''' 9117 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 9118 ''' 9119 ID of the secret store containing credentials for this resource, if any. 9120 ''' 9121 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 9122 ''' 9123 Tags is a map of key, value pairs. 9124 ''' 9125 self.tls_required = tls_required if tls_required is not None else False 9126 ''' 9127 9128 ''' 9129 self.username = username if username is not None else '' 9130 ''' 9131 9132 ''' 9133 9134 def __repr__(self): 9135 return '<sdm.RabbitMQAMQP091 ' + \ 9136 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 9137 'healthy: ' + repr(self.healthy) + ' ' +\ 9138 'hostname: ' + repr(self.hostname) + ' ' +\ 9139 'id: ' + repr(self.id) + ' ' +\ 9140 'name: ' + repr(self.name) + ' ' +\ 9141 'password: ' + repr(self.password) + ' ' +\ 9142 'port: ' + repr(self.port) + ' ' +\ 9143 'port_override: ' + repr(self.port_override) + ' ' +\ 9144 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 9145 'tags: ' + repr(self.tags) + ' ' +\ 9146 'tls_required: ' + repr(self.tls_required) + ' ' +\ 9147 'username: ' + repr(self.username) + ' ' +\ 9148 '>' 9149 9150 def to_dict(self): 9151 return { 9152 'egress_filter': self.egress_filter, 9153 'healthy': self.healthy, 9154 'hostname': self.hostname, 9155 'id': self.id, 9156 'name': self.name, 9157 'password': self.password, 9158 'port': self.port, 9159 'port_override': self.port_override, 9160 'secret_store_id': self.secret_store_id, 9161 'tags': self.tags, 9162 'tls_required': self.tls_required, 9163 'username': self.username, 9164 } 9165 9166 @classmethod 9167 def from_dict(cls, d): 9168 return cls( 9169 egress_filter=d.get('egress_filter'), 9170 healthy=d.get('healthy'), 9171 hostname=d.get('hostname'), 9172 id=d.get('id'), 9173 name=d.get('name'), 9174 password=d.get('password'), 9175 port=d.get('port'), 9176 port_override=d.get('port_override'), 9177 secret_store_id=d.get('secret_store_id'), 9178 tags=d.get('tags'), 9179 tls_required=d.get('tls_required'), 9180 username=d.get('username'), 9181 ) 9182 9183 9184class RateLimitMetadata: 9185 ''' 9186 RateLimitMetadata contains information about remaining requests avaialable 9187 to the user over some timeframe. 9188 ''' 9189 __slots__ = [ 9190 'bucket', 9191 'limit', 9192 'remaining', 9193 'reset_at', 9194 ] 9195 9196 def __init__( 9197 self, 9198 bucket=None, 9199 limit=None, 9200 remaining=None, 9201 reset_at=None, 9202 ): 9203 self.bucket = bucket if bucket is not None else '' 9204 ''' 9205 The bucket this user/token is associated with, which may be shared between 9206 multiple users/tokens. 9207 ''' 9208 self.limit = limit if limit is not None else 0 9209 ''' 9210 How many total requests the user/token is authorized to make before being 9211 rate limited. 9212 ''' 9213 self.remaining = remaining if remaining is not None else 0 9214 ''' 9215 How many remaining requests out of the limit are still avaialable. 9216 ''' 9217 self.reset_at = reset_at if reset_at is not None else None 9218 ''' 9219 The time when remaining will be reset to limit. 9220 ''' 9221 9222 def __repr__(self): 9223 return '<sdm.RateLimitMetadata ' + \ 9224 'bucket: ' + repr(self.bucket) + ' ' +\ 9225 'limit: ' + repr(self.limit) + ' ' +\ 9226 'remaining: ' + repr(self.remaining) + ' ' +\ 9227 'reset_at: ' + repr(self.reset_at) + ' ' +\ 9228 '>' 9229 9230 def to_dict(self): 9231 return { 9232 'bucket': self.bucket, 9233 'limit': self.limit, 9234 'remaining': self.remaining, 9235 'reset_at': self.reset_at, 9236 } 9237 9238 @classmethod 9239 def from_dict(cls, d): 9240 return cls( 9241 bucket=d.get('bucket'), 9242 limit=d.get('limit'), 9243 remaining=d.get('remaining'), 9244 reset_at=d.get('reset_at'), 9245 ) 9246 9247 9248class RawTCP: 9249 ''' 9250 9251 ''' 9252 __slots__ = [ 9253 'egress_filter', 9254 'healthy', 9255 'hostname', 9256 'id', 9257 'name', 9258 'port', 9259 'port_override', 9260 'secret_store_id', 9261 'tags', 9262 ] 9263 9264 def __init__( 9265 self, 9266 egress_filter=None, 9267 healthy=None, 9268 hostname=None, 9269 id=None, 9270 name=None, 9271 port=None, 9272 port_override=None, 9273 secret_store_id=None, 9274 tags=None, 9275 ): 9276 self.egress_filter = egress_filter if egress_filter is not None else '' 9277 ''' 9278 A filter applied to the routing logic to pin datasource to nodes. 9279 ''' 9280 self.healthy = healthy if healthy is not None else False 9281 ''' 9282 True if the datasource is reachable and the credentials are valid. 9283 ''' 9284 self.hostname = hostname if hostname is not None else '' 9285 ''' 9286 9287 ''' 9288 self.id = id if id is not None else '' 9289 ''' 9290 Unique identifier of the Resource. 9291 ''' 9292 self.name = name if name is not None else '' 9293 ''' 9294 Unique human-readable name of the Resource. 9295 ''' 9296 self.port = port if port is not None else 0 9297 ''' 9298 9299 ''' 9300 self.port_override = port_override if port_override is not None else 0 9301 ''' 9302 9303 ''' 9304 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 9305 ''' 9306 ID of the secret store containing credentials for this resource, if any. 9307 ''' 9308 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 9309 ''' 9310 Tags is a map of key, value pairs. 9311 ''' 9312 9313 def __repr__(self): 9314 return '<sdm.RawTCP ' + \ 9315 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 9316 'healthy: ' + repr(self.healthy) + ' ' +\ 9317 'hostname: ' + repr(self.hostname) + ' ' +\ 9318 'id: ' + repr(self.id) + ' ' +\ 9319 'name: ' + repr(self.name) + ' ' +\ 9320 'port: ' + repr(self.port) + ' ' +\ 9321 'port_override: ' + repr(self.port_override) + ' ' +\ 9322 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 9323 'tags: ' + repr(self.tags) + ' ' +\ 9324 '>' 9325 9326 def to_dict(self): 9327 return { 9328 'egress_filter': self.egress_filter, 9329 'healthy': self.healthy, 9330 'hostname': self.hostname, 9331 'id': self.id, 9332 'name': self.name, 9333 'port': self.port, 9334 'port_override': self.port_override, 9335 'secret_store_id': self.secret_store_id, 9336 'tags': self.tags, 9337 } 9338 9339 @classmethod 9340 def from_dict(cls, d): 9341 return cls( 9342 egress_filter=d.get('egress_filter'), 9343 healthy=d.get('healthy'), 9344 hostname=d.get('hostname'), 9345 id=d.get('id'), 9346 name=d.get('name'), 9347 port=d.get('port'), 9348 port_override=d.get('port_override'), 9349 secret_store_id=d.get('secret_store_id'), 9350 tags=d.get('tags'), 9351 ) 9352 9353 9354class Redis: 9355 ''' 9356 9357 ''' 9358 __slots__ = [ 9359 'egress_filter', 9360 'healthy', 9361 'hostname', 9362 'id', 9363 'name', 9364 'password', 9365 'port', 9366 'port_override', 9367 'secret_store_id', 9368 'tags', 9369 ] 9370 9371 def __init__( 9372 self, 9373 egress_filter=None, 9374 healthy=None, 9375 hostname=None, 9376 id=None, 9377 name=None, 9378 password=None, 9379 port=None, 9380 port_override=None, 9381 secret_store_id=None, 9382 tags=None, 9383 ): 9384 self.egress_filter = egress_filter if egress_filter is not None else '' 9385 ''' 9386 A filter applied to the routing logic to pin datasource to nodes. 9387 ''' 9388 self.healthy = healthy if healthy is not None else False 9389 ''' 9390 True if the datasource is reachable and the credentials are valid. 9391 ''' 9392 self.hostname = hostname if hostname is not None else '' 9393 ''' 9394 9395 ''' 9396 self.id = id if id is not None else '' 9397 ''' 9398 Unique identifier of the Resource. 9399 ''' 9400 self.name = name if name is not None else '' 9401 ''' 9402 Unique human-readable name of the Resource. 9403 ''' 9404 self.password = password if password is not None else '' 9405 ''' 9406 9407 ''' 9408 self.port = port if port is not None else 0 9409 ''' 9410 9411 ''' 9412 self.port_override = port_override if port_override is not None else 0 9413 ''' 9414 9415 ''' 9416 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 9417 ''' 9418 ID of the secret store containing credentials for this resource, if any. 9419 ''' 9420 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 9421 ''' 9422 Tags is a map of key, value pairs. 9423 ''' 9424 9425 def __repr__(self): 9426 return '<sdm.Redis ' + \ 9427 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 9428 'healthy: ' + repr(self.healthy) + ' ' +\ 9429 'hostname: ' + repr(self.hostname) + ' ' +\ 9430 'id: ' + repr(self.id) + ' ' +\ 9431 'name: ' + repr(self.name) + ' ' +\ 9432 'password: ' + repr(self.password) + ' ' +\ 9433 'port: ' + repr(self.port) + ' ' +\ 9434 'port_override: ' + repr(self.port_override) + ' ' +\ 9435 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 9436 'tags: ' + repr(self.tags) + ' ' +\ 9437 '>' 9438 9439 def to_dict(self): 9440 return { 9441 'egress_filter': self.egress_filter, 9442 'healthy': self.healthy, 9443 'hostname': self.hostname, 9444 'id': self.id, 9445 'name': self.name, 9446 'password': self.password, 9447 'port': self.port, 9448 'port_override': self.port_override, 9449 'secret_store_id': self.secret_store_id, 9450 'tags': self.tags, 9451 } 9452 9453 @classmethod 9454 def from_dict(cls, d): 9455 return cls( 9456 egress_filter=d.get('egress_filter'), 9457 healthy=d.get('healthy'), 9458 hostname=d.get('hostname'), 9459 id=d.get('id'), 9460 name=d.get('name'), 9461 password=d.get('password'), 9462 port=d.get('port'), 9463 port_override=d.get('port_override'), 9464 secret_store_id=d.get('secret_store_id'), 9465 tags=d.get('tags'), 9466 ) 9467 9468 9469class Redshift: 9470 ''' 9471 9472 ''' 9473 __slots__ = [ 9474 'database', 9475 'egress_filter', 9476 'healthy', 9477 'hostname', 9478 'id', 9479 'name', 9480 'override_database', 9481 'password', 9482 'port', 9483 'port_override', 9484 'secret_store_id', 9485 'tags', 9486 'username', 9487 ] 9488 9489 def __init__( 9490 self, 9491 database=None, 9492 egress_filter=None, 9493 healthy=None, 9494 hostname=None, 9495 id=None, 9496 name=None, 9497 override_database=None, 9498 password=None, 9499 port=None, 9500 port_override=None, 9501 secret_store_id=None, 9502 tags=None, 9503 username=None, 9504 ): 9505 self.database = database if database is not None else '' 9506 ''' 9507 9508 ''' 9509 self.egress_filter = egress_filter if egress_filter is not None else '' 9510 ''' 9511 A filter applied to the routing logic to pin datasource to nodes. 9512 ''' 9513 self.healthy = healthy if healthy is not None else False 9514 ''' 9515 True if the datasource is reachable and the credentials are valid. 9516 ''' 9517 self.hostname = hostname if hostname is not None else '' 9518 ''' 9519 9520 ''' 9521 self.id = id if id is not None else '' 9522 ''' 9523 Unique identifier of the Resource. 9524 ''' 9525 self.name = name if name is not None else '' 9526 ''' 9527 Unique human-readable name of the Resource. 9528 ''' 9529 self.override_database = override_database if override_database is not None else False 9530 ''' 9531 9532 ''' 9533 self.password = password if password is not None else '' 9534 ''' 9535 9536 ''' 9537 self.port = port if port is not None else 0 9538 ''' 9539 9540 ''' 9541 self.port_override = port_override if port_override is not None else 0 9542 ''' 9543 9544 ''' 9545 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 9546 ''' 9547 ID of the secret store containing credentials for this resource, if any. 9548 ''' 9549 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 9550 ''' 9551 Tags is a map of key, value pairs. 9552 ''' 9553 self.username = username if username is not None else '' 9554 ''' 9555 9556 ''' 9557 9558 def __repr__(self): 9559 return '<sdm.Redshift ' + \ 9560 'database: ' + repr(self.database) + ' ' +\ 9561 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 9562 'healthy: ' + repr(self.healthy) + ' ' +\ 9563 'hostname: ' + repr(self.hostname) + ' ' +\ 9564 'id: ' + repr(self.id) + ' ' +\ 9565 'name: ' + repr(self.name) + ' ' +\ 9566 'override_database: ' + repr(self.override_database) + ' ' +\ 9567 'password: ' + repr(self.password) + ' ' +\ 9568 'port: ' + repr(self.port) + ' ' +\ 9569 'port_override: ' + repr(self.port_override) + ' ' +\ 9570 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 9571 'tags: ' + repr(self.tags) + ' ' +\ 9572 'username: ' + repr(self.username) + ' ' +\ 9573 '>' 9574 9575 def to_dict(self): 9576 return { 9577 'database': self.database, 9578 'egress_filter': self.egress_filter, 9579 'healthy': self.healthy, 9580 'hostname': self.hostname, 9581 'id': self.id, 9582 'name': self.name, 9583 'override_database': self.override_database, 9584 'password': self.password, 9585 'port': self.port, 9586 'port_override': self.port_override, 9587 'secret_store_id': self.secret_store_id, 9588 'tags': self.tags, 9589 'username': self.username, 9590 } 9591 9592 @classmethod 9593 def from_dict(cls, d): 9594 return cls( 9595 database=d.get('database'), 9596 egress_filter=d.get('egress_filter'), 9597 healthy=d.get('healthy'), 9598 hostname=d.get('hostname'), 9599 id=d.get('id'), 9600 name=d.get('name'), 9601 override_database=d.get('override_database'), 9602 password=d.get('password'), 9603 port=d.get('port'), 9604 port_override=d.get('port_override'), 9605 secret_store_id=d.get('secret_store_id'), 9606 tags=d.get('tags'), 9607 username=d.get('username'), 9608 ) 9609 9610 9611class Relay: 9612 ''' 9613 Relay represents a StrongDM CLI installation running in relay mode. 9614 ''' 9615 __slots__ = [ 9616 'gateway_filter', 9617 'id', 9618 'name', 9619 'state', 9620 'tags', 9621 ] 9622 9623 def __init__( 9624 self, 9625 gateway_filter=None, 9626 id=None, 9627 name=None, 9628 state=None, 9629 tags=None, 9630 ): 9631 self.gateway_filter = gateway_filter if gateway_filter is not None else '' 9632 ''' 9633 GatewayFilter can be used to restrict the peering between relays and 9634 gateways. 9635 ''' 9636 self.id = id if id is not None else '' 9637 ''' 9638 Unique identifier of the Relay. 9639 ''' 9640 self.name = name if name is not None else '' 9641 ''' 9642 Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create. 9643 ''' 9644 self.state = state if state is not None else '' 9645 ''' 9646 The current state of the relay. One of: "new", "verifying_restart", 9647 "awaiting_restart", "restarting", "started", "stopped", "dead", 9648 "unknown". 9649 ''' 9650 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 9651 ''' 9652 Tags is a map of key, value pairs. 9653 ''' 9654 9655 def __repr__(self): 9656 return '<sdm.Relay ' + \ 9657 'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\ 9658 'id: ' + repr(self.id) + ' ' +\ 9659 'name: ' + repr(self.name) + ' ' +\ 9660 'state: ' + repr(self.state) + ' ' +\ 9661 'tags: ' + repr(self.tags) + ' ' +\ 9662 '>' 9663 9664 def to_dict(self): 9665 return { 9666 'gateway_filter': self.gateway_filter, 9667 'id': self.id, 9668 'name': self.name, 9669 'state': self.state, 9670 'tags': self.tags, 9671 } 9672 9673 @classmethod 9674 def from_dict(cls, d): 9675 return cls( 9676 gateway_filter=d.get('gateway_filter'), 9677 id=d.get('id'), 9678 name=d.get('name'), 9679 state=d.get('state'), 9680 tags=d.get('tags'), 9681 ) 9682 9683 9684class ResourceCreateResponse: 9685 ''' 9686 ResourceCreateResponse reports how the Resources were created in the system. 9687 ''' 9688 __slots__ = [ 9689 'meta', 9690 'rate_limit', 9691 'resource', 9692 ] 9693 9694 def __init__( 9695 self, 9696 meta=None, 9697 rate_limit=None, 9698 resource=None, 9699 ): 9700 self.meta = meta if meta is not None else None 9701 ''' 9702 Reserved for future use. 9703 ''' 9704 self.rate_limit = rate_limit if rate_limit is not None else None 9705 ''' 9706 Rate limit information. 9707 ''' 9708 self.resource = resource if resource is not None else None 9709 ''' 9710 The created Resource. 9711 ''' 9712 9713 def __repr__(self): 9714 return '<sdm.ResourceCreateResponse ' + \ 9715 'meta: ' + repr(self.meta) + ' ' +\ 9716 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 9717 'resource: ' + repr(self.resource) + ' ' +\ 9718 '>' 9719 9720 def to_dict(self): 9721 return { 9722 'meta': self.meta, 9723 'rate_limit': self.rate_limit, 9724 'resource': self.resource, 9725 } 9726 9727 @classmethod 9728 def from_dict(cls, d): 9729 return cls( 9730 meta=d.get('meta'), 9731 rate_limit=d.get('rate_limit'), 9732 resource=d.get('resource'), 9733 ) 9734 9735 9736class ResourceDeleteResponse: 9737 ''' 9738 ResourceDeleteResponse returns information about a Resource that was deleted. 9739 ''' 9740 __slots__ = [ 9741 'meta', 9742 'rate_limit', 9743 ] 9744 9745 def __init__( 9746 self, 9747 meta=None, 9748 rate_limit=None, 9749 ): 9750 self.meta = meta if meta is not None else None 9751 ''' 9752 Reserved for future use. 9753 ''' 9754 self.rate_limit = rate_limit if rate_limit is not None else None 9755 ''' 9756 Rate limit information. 9757 ''' 9758 9759 def __repr__(self): 9760 return '<sdm.ResourceDeleteResponse ' + \ 9761 'meta: ' + repr(self.meta) + ' ' +\ 9762 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 9763 '>' 9764 9765 def to_dict(self): 9766 return { 9767 'meta': self.meta, 9768 'rate_limit': self.rate_limit, 9769 } 9770 9771 @classmethod 9772 def from_dict(cls, d): 9773 return cls( 9774 meta=d.get('meta'), 9775 rate_limit=d.get('rate_limit'), 9776 ) 9777 9778 9779class ResourceGetResponse: 9780 ''' 9781 ResourceGetResponse returns a requested Resource. 9782 ''' 9783 __slots__ = [ 9784 'meta', 9785 'rate_limit', 9786 'resource', 9787 ] 9788 9789 def __init__( 9790 self, 9791 meta=None, 9792 rate_limit=None, 9793 resource=None, 9794 ): 9795 self.meta = meta if meta is not None else None 9796 ''' 9797 Reserved for future use. 9798 ''' 9799 self.rate_limit = rate_limit if rate_limit is not None else None 9800 ''' 9801 Rate limit information. 9802 ''' 9803 self.resource = resource if resource is not None else None 9804 ''' 9805 The requested Resource. 9806 ''' 9807 9808 def __repr__(self): 9809 return '<sdm.ResourceGetResponse ' + \ 9810 'meta: ' + repr(self.meta) + ' ' +\ 9811 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 9812 'resource: ' + repr(self.resource) + ' ' +\ 9813 '>' 9814 9815 def to_dict(self): 9816 return { 9817 'meta': self.meta, 9818 'rate_limit': self.rate_limit, 9819 'resource': self.resource, 9820 } 9821 9822 @classmethod 9823 def from_dict(cls, d): 9824 return cls( 9825 meta=d.get('meta'), 9826 rate_limit=d.get('rate_limit'), 9827 resource=d.get('resource'), 9828 ) 9829 9830 9831class ResourceUpdateResponse: 9832 ''' 9833 ResourceUpdateResponse returns the fields of a Resource after it has been updated by 9834 a ResourceUpdateRequest. 9835 ''' 9836 __slots__ = [ 9837 'meta', 9838 'rate_limit', 9839 'resource', 9840 ] 9841 9842 def __init__( 9843 self, 9844 meta=None, 9845 rate_limit=None, 9846 resource=None, 9847 ): 9848 self.meta = meta if meta is not None else None 9849 ''' 9850 Reserved for future use. 9851 ''' 9852 self.rate_limit = rate_limit if rate_limit is not None else None 9853 ''' 9854 Rate limit information. 9855 ''' 9856 self.resource = resource if resource is not None else None 9857 ''' 9858 The updated Resource. 9859 ''' 9860 9861 def __repr__(self): 9862 return '<sdm.ResourceUpdateResponse ' + \ 9863 'meta: ' + repr(self.meta) + ' ' +\ 9864 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 9865 'resource: ' + repr(self.resource) + ' ' +\ 9866 '>' 9867 9868 def to_dict(self): 9869 return { 9870 'meta': self.meta, 9871 'rate_limit': self.rate_limit, 9872 'resource': self.resource, 9873 } 9874 9875 @classmethod 9876 def from_dict(cls, d): 9877 return cls( 9878 meta=d.get('meta'), 9879 rate_limit=d.get('rate_limit'), 9880 resource=d.get('resource'), 9881 ) 9882 9883 9884class Role: 9885 ''' 9886 A Role has a list of access rules which determine which Resources the members 9887 of the Role have access to. An Account can be a member of multiple Roles via 9888 AccountAttachments. 9889 ''' 9890 __slots__ = [ 9891 'access_rules', 9892 'composite', 9893 'id', 9894 'name', 9895 'tags', 9896 ] 9897 9898 def __init__( 9899 self, 9900 access_rules=None, 9901 composite=None, 9902 id=None, 9903 name=None, 9904 tags=None, 9905 ): 9906 self.access_rules = access_rules if access_rules is not None else _porcelain_zero_value_access_rules( 9907 ) 9908 ''' 9909 AccessRules is a list of access rules defining the resources this Role has access to. 9910 ''' 9911 self.composite = composite if composite is not None else False 9912 ''' 9913 Composite is true if the Role is a composite role. 9914 9915 Deprecated: composite roles are deprecated, use multi-role via 9916 AccountAttachments instead. 9917 ''' 9918 self.id = id if id is not None else '' 9919 ''' 9920 Unique identifier of the Role. 9921 ''' 9922 self.name = name if name is not None else '' 9923 ''' 9924 Unique human-readable name of the Role. 9925 ''' 9926 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 9927 ''' 9928 Tags is a map of key, value pairs. 9929 ''' 9930 9931 def __repr__(self): 9932 return '<sdm.Role ' + \ 9933 'access_rules: ' + repr(self.access_rules) + ' ' +\ 9934 'composite: ' + repr(self.composite) + ' ' +\ 9935 'id: ' + repr(self.id) + ' ' +\ 9936 'name: ' + repr(self.name) + ' ' +\ 9937 'tags: ' + repr(self.tags) + ' ' +\ 9938 '>' 9939 9940 def to_dict(self): 9941 return { 9942 'access_rules': self.access_rules, 9943 'composite': self.composite, 9944 'id': self.id, 9945 'name': self.name, 9946 'tags': self.tags, 9947 } 9948 9949 @classmethod 9950 def from_dict(cls, d): 9951 return cls( 9952 access_rules=d.get('access_rules'), 9953 composite=d.get('composite'), 9954 id=d.get('id'), 9955 name=d.get('name'), 9956 tags=d.get('tags'), 9957 ) 9958 9959 9960class RoleAttachment: 9961 ''' 9962 A RoleAttachment assigns a role to a composite role. 9963 9964 Deprecated: use multi-role via AccountAttachments instead. 9965 ''' 9966 __slots__ = [ 9967 'attached_role_id', 9968 'composite_role_id', 9969 'id', 9970 ] 9971 9972 def __init__( 9973 self, 9974 attached_role_id=None, 9975 composite_role_id=None, 9976 id=None, 9977 ): 9978 self.attached_role_id = attached_role_id if attached_role_id is not None else '' 9979 ''' 9980 The id of the attached role of this RoleAttachment. 9981 ''' 9982 self.composite_role_id = composite_role_id if composite_role_id is not None else '' 9983 ''' 9984 The id of the composite role of this RoleAttachment. 9985 ''' 9986 self.id = id if id is not None else '' 9987 ''' 9988 Unique identifier of the RoleAttachment. 9989 ''' 9990 9991 def __repr__(self): 9992 return '<sdm.RoleAttachment ' + \ 9993 'attached_role_id: ' + repr(self.attached_role_id) + ' ' +\ 9994 'composite_role_id: ' + repr(self.composite_role_id) + ' ' +\ 9995 'id: ' + repr(self.id) + ' ' +\ 9996 '>' 9997 9998 def to_dict(self): 9999 return { 10000 'attached_role_id': self.attached_role_id, 10001 'composite_role_id': self.composite_role_id, 10002 'id': self.id, 10003 } 10004 10005 @classmethod 10006 def from_dict(cls, d): 10007 return cls( 10008 attached_role_id=d.get('attached_role_id'), 10009 composite_role_id=d.get('composite_role_id'), 10010 id=d.get('id'), 10011 ) 10012 10013 10014class RoleAttachmentCreateResponse: 10015 ''' 10016 RoleAttachmentCreateResponse reports how the RoleAttachments were created in the system. 10017 10018 Deprecated: use multi-role via AccountAttachments instead. 10019 ''' 10020 __slots__ = [ 10021 'meta', 10022 'rate_limit', 10023 'role_attachment', 10024 ] 10025 10026 def __init__( 10027 self, 10028 meta=None, 10029 rate_limit=None, 10030 role_attachment=None, 10031 ): 10032 self.meta = meta if meta is not None else None 10033 ''' 10034 Reserved for future use. 10035 ''' 10036 self.rate_limit = rate_limit if rate_limit is not None else None 10037 ''' 10038 Rate limit information. 10039 ''' 10040 self.role_attachment = role_attachment if role_attachment is not None else None 10041 ''' 10042 The created RoleAttachment. 10043 ''' 10044 10045 def __repr__(self): 10046 return '<sdm.RoleAttachmentCreateResponse ' + \ 10047 'meta: ' + repr(self.meta) + ' ' +\ 10048 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 10049 'role_attachment: ' + repr(self.role_attachment) + ' ' +\ 10050 '>' 10051 10052 def to_dict(self): 10053 return { 10054 'meta': self.meta, 10055 'rate_limit': self.rate_limit, 10056 'role_attachment': self.role_attachment, 10057 } 10058 10059 @classmethod 10060 def from_dict(cls, d): 10061 return cls( 10062 meta=d.get('meta'), 10063 rate_limit=d.get('rate_limit'), 10064 role_attachment=d.get('role_attachment'), 10065 ) 10066 10067 10068class RoleAttachmentDeleteResponse: 10069 ''' 10070 RoleAttachmentDeleteResponse returns information about a RoleAttachment that was deleted. 10071 10072 Deprecated: use multi-role via AccountAttachments instead. 10073 ''' 10074 __slots__ = [ 10075 'meta', 10076 'rate_limit', 10077 ] 10078 10079 def __init__( 10080 self, 10081 meta=None, 10082 rate_limit=None, 10083 ): 10084 self.meta = meta if meta is not None else None 10085 ''' 10086 Reserved for future use. 10087 ''' 10088 self.rate_limit = rate_limit if rate_limit is not None else None 10089 ''' 10090 Rate limit information. 10091 ''' 10092 10093 def __repr__(self): 10094 return '<sdm.RoleAttachmentDeleteResponse ' + \ 10095 'meta: ' + repr(self.meta) + ' ' +\ 10096 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 10097 '>' 10098 10099 def to_dict(self): 10100 return { 10101 'meta': self.meta, 10102 'rate_limit': self.rate_limit, 10103 } 10104 10105 @classmethod 10106 def from_dict(cls, d): 10107 return cls( 10108 meta=d.get('meta'), 10109 rate_limit=d.get('rate_limit'), 10110 ) 10111 10112 10113class RoleAttachmentGetResponse: 10114 ''' 10115 RoleAttachmentGetResponse returns a requested RoleAttachment. 10116 10117 Deprecated: use multi-role via AccountAttachments instead. 10118 ''' 10119 __slots__ = [ 10120 'meta', 10121 'rate_limit', 10122 'role_attachment', 10123 ] 10124 10125 def __init__( 10126 self, 10127 meta=None, 10128 rate_limit=None, 10129 role_attachment=None, 10130 ): 10131 self.meta = meta if meta is not None else None 10132 ''' 10133 Reserved for future use. 10134 ''' 10135 self.rate_limit = rate_limit if rate_limit is not None else None 10136 ''' 10137 Rate limit information. 10138 ''' 10139 self.role_attachment = role_attachment if role_attachment is not None else None 10140 ''' 10141 The requested RoleAttachment. 10142 ''' 10143 10144 def __repr__(self): 10145 return '<sdm.RoleAttachmentGetResponse ' + \ 10146 'meta: ' + repr(self.meta) + ' ' +\ 10147 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 10148 'role_attachment: ' + repr(self.role_attachment) + ' ' +\ 10149 '>' 10150 10151 def to_dict(self): 10152 return { 10153 'meta': self.meta, 10154 'rate_limit': self.rate_limit, 10155 'role_attachment': self.role_attachment, 10156 } 10157 10158 @classmethod 10159 def from_dict(cls, d): 10160 return cls( 10161 meta=d.get('meta'), 10162 rate_limit=d.get('rate_limit'), 10163 role_attachment=d.get('role_attachment'), 10164 ) 10165 10166 10167class RoleCreateResponse: 10168 ''' 10169 RoleCreateResponse reports how the Roles were created in the system. It can 10170 communicate partial successes or failures. 10171 ''' 10172 __slots__ = [ 10173 'meta', 10174 'rate_limit', 10175 'role', 10176 ] 10177 10178 def __init__( 10179 self, 10180 meta=None, 10181 rate_limit=None, 10182 role=None, 10183 ): 10184 self.meta = meta if meta is not None else None 10185 ''' 10186 Reserved for future use. 10187 ''' 10188 self.rate_limit = rate_limit if rate_limit is not None else None 10189 ''' 10190 Rate limit information. 10191 ''' 10192 self.role = role if role is not None else None 10193 ''' 10194 The created Role. 10195 ''' 10196 10197 def __repr__(self): 10198 return '<sdm.RoleCreateResponse ' + \ 10199 'meta: ' + repr(self.meta) + ' ' +\ 10200 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 10201 'role: ' + repr(self.role) + ' ' +\ 10202 '>' 10203 10204 def to_dict(self): 10205 return { 10206 'meta': self.meta, 10207 'rate_limit': self.rate_limit, 10208 'role': self.role, 10209 } 10210 10211 @classmethod 10212 def from_dict(cls, d): 10213 return cls( 10214 meta=d.get('meta'), 10215 rate_limit=d.get('rate_limit'), 10216 role=d.get('role'), 10217 ) 10218 10219 10220class RoleDeleteResponse: 10221 ''' 10222 RoleDeleteResponse returns information about a Role that was deleted. 10223 ''' 10224 __slots__ = [ 10225 'meta', 10226 'rate_limit', 10227 ] 10228 10229 def __init__( 10230 self, 10231 meta=None, 10232 rate_limit=None, 10233 ): 10234 self.meta = meta if meta is not None else None 10235 ''' 10236 Reserved for future use. 10237 ''' 10238 self.rate_limit = rate_limit if rate_limit is not None else None 10239 ''' 10240 Rate limit information. 10241 ''' 10242 10243 def __repr__(self): 10244 return '<sdm.RoleDeleteResponse ' + \ 10245 'meta: ' + repr(self.meta) + ' ' +\ 10246 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 10247 '>' 10248 10249 def to_dict(self): 10250 return { 10251 'meta': self.meta, 10252 'rate_limit': self.rate_limit, 10253 } 10254 10255 @classmethod 10256 def from_dict(cls, d): 10257 return cls( 10258 meta=d.get('meta'), 10259 rate_limit=d.get('rate_limit'), 10260 ) 10261 10262 10263class RoleGetResponse: 10264 ''' 10265 RoleGetResponse returns a requested Role. 10266 ''' 10267 __slots__ = [ 10268 'meta', 10269 'rate_limit', 10270 'role', 10271 ] 10272 10273 def __init__( 10274 self, 10275 meta=None, 10276 rate_limit=None, 10277 role=None, 10278 ): 10279 self.meta = meta if meta is not None else None 10280 ''' 10281 Reserved for future use. 10282 ''' 10283 self.rate_limit = rate_limit if rate_limit is not None else None 10284 ''' 10285 Rate limit information. 10286 ''' 10287 self.role = role if role is not None else None 10288 ''' 10289 The requested Role. 10290 ''' 10291 10292 def __repr__(self): 10293 return '<sdm.RoleGetResponse ' + \ 10294 'meta: ' + repr(self.meta) + ' ' +\ 10295 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 10296 'role: ' + repr(self.role) + ' ' +\ 10297 '>' 10298 10299 def to_dict(self): 10300 return { 10301 'meta': self.meta, 10302 'rate_limit': self.rate_limit, 10303 'role': self.role, 10304 } 10305 10306 @classmethod 10307 def from_dict(cls, d): 10308 return cls( 10309 meta=d.get('meta'), 10310 rate_limit=d.get('rate_limit'), 10311 role=d.get('role'), 10312 ) 10313 10314 10315class RoleGrant: 10316 ''' 10317 A RoleGrant connects a resource to a role, granting members of the role access to that resource. 10318 10319 Deprecated: use Role access rules instead. 10320 ''' 10321 __slots__ = [ 10322 'id', 10323 'resource_id', 10324 'role_id', 10325 ] 10326 10327 def __init__( 10328 self, 10329 id=None, 10330 resource_id=None, 10331 role_id=None, 10332 ): 10333 self.id = id if id is not None else '' 10334 ''' 10335 Unique identifier of the RoleGrant. 10336 ''' 10337 self.resource_id = resource_id if resource_id is not None else '' 10338 ''' 10339 The id of the resource of this RoleGrant. 10340 ''' 10341 self.role_id = role_id if role_id is not None else '' 10342 ''' 10343 The id of the attached role of this RoleGrant. 10344 ''' 10345 10346 def __repr__(self): 10347 return '<sdm.RoleGrant ' + \ 10348 'id: ' + repr(self.id) + ' ' +\ 10349 'resource_id: ' + repr(self.resource_id) + ' ' +\ 10350 'role_id: ' + repr(self.role_id) + ' ' +\ 10351 '>' 10352 10353 def to_dict(self): 10354 return { 10355 'id': self.id, 10356 'resource_id': self.resource_id, 10357 'role_id': self.role_id, 10358 } 10359 10360 @classmethod 10361 def from_dict(cls, d): 10362 return cls( 10363 id=d.get('id'), 10364 resource_id=d.get('resource_id'), 10365 role_id=d.get('role_id'), 10366 ) 10367 10368 10369class RoleGrantCreateResponse: 10370 ''' 10371 RoleGrantCreateResponse reports how the RoleGrants were created in the system. 10372 10373 Deprecated: use Role access rules instead. 10374 ''' 10375 __slots__ = [ 10376 'meta', 10377 'rate_limit', 10378 'role_grant', 10379 ] 10380 10381 def __init__( 10382 self, 10383 meta=None, 10384 rate_limit=None, 10385 role_grant=None, 10386 ): 10387 self.meta = meta if meta is not None else None 10388 ''' 10389 Reserved for future use. 10390 ''' 10391 self.rate_limit = rate_limit if rate_limit is not None else None 10392 ''' 10393 Rate limit information. 10394 ''' 10395 self.role_grant = role_grant if role_grant is not None else None 10396 ''' 10397 The created RoleGrant. 10398 ''' 10399 10400 def __repr__(self): 10401 return '<sdm.RoleGrantCreateResponse ' + \ 10402 'meta: ' + repr(self.meta) + ' ' +\ 10403 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 10404 'role_grant: ' + repr(self.role_grant) + ' ' +\ 10405 '>' 10406 10407 def to_dict(self): 10408 return { 10409 'meta': self.meta, 10410 'rate_limit': self.rate_limit, 10411 'role_grant': self.role_grant, 10412 } 10413 10414 @classmethod 10415 def from_dict(cls, d): 10416 return cls( 10417 meta=d.get('meta'), 10418 rate_limit=d.get('rate_limit'), 10419 role_grant=d.get('role_grant'), 10420 ) 10421 10422 10423class RoleGrantDeleteResponse: 10424 ''' 10425 RoleGrantDeleteResponse returns information about a RoleGrant that was deleted. 10426 10427 Deprecated: use Role access rules instead. 10428 ''' 10429 __slots__ = [ 10430 'meta', 10431 'rate_limit', 10432 ] 10433 10434 def __init__( 10435 self, 10436 meta=None, 10437 rate_limit=None, 10438 ): 10439 self.meta = meta if meta is not None else None 10440 ''' 10441 Reserved for future use. 10442 ''' 10443 self.rate_limit = rate_limit if rate_limit is not None else None 10444 ''' 10445 Rate limit information. 10446 ''' 10447 10448 def __repr__(self): 10449 return '<sdm.RoleGrantDeleteResponse ' + \ 10450 'meta: ' + repr(self.meta) + ' ' +\ 10451 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 10452 '>' 10453 10454 def to_dict(self): 10455 return { 10456 'meta': self.meta, 10457 'rate_limit': self.rate_limit, 10458 } 10459 10460 @classmethod 10461 def from_dict(cls, d): 10462 return cls( 10463 meta=d.get('meta'), 10464 rate_limit=d.get('rate_limit'), 10465 ) 10466 10467 10468class RoleGrantGetResponse: 10469 ''' 10470 RoleGrantGetResponse returns a requested RoleGrant. 10471 10472 Deprecated: use Role access rules instead. 10473 ''' 10474 __slots__ = [ 10475 'meta', 10476 'rate_limit', 10477 'role_grant', 10478 ] 10479 10480 def __init__( 10481 self, 10482 meta=None, 10483 rate_limit=None, 10484 role_grant=None, 10485 ): 10486 self.meta = meta if meta is not None else None 10487 ''' 10488 Reserved for future use. 10489 ''' 10490 self.rate_limit = rate_limit if rate_limit is not None else None 10491 ''' 10492 Rate limit information. 10493 ''' 10494 self.role_grant = role_grant if role_grant is not None else None 10495 ''' 10496 The requested RoleGrant. 10497 ''' 10498 10499 def __repr__(self): 10500 return '<sdm.RoleGrantGetResponse ' + \ 10501 'meta: ' + repr(self.meta) + ' ' +\ 10502 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 10503 'role_grant: ' + repr(self.role_grant) + ' ' +\ 10504 '>' 10505 10506 def to_dict(self): 10507 return { 10508 'meta': self.meta, 10509 'rate_limit': self.rate_limit, 10510 'role_grant': self.role_grant, 10511 } 10512 10513 @classmethod 10514 def from_dict(cls, d): 10515 return cls( 10516 meta=d.get('meta'), 10517 rate_limit=d.get('rate_limit'), 10518 role_grant=d.get('role_grant'), 10519 ) 10520 10521 10522class RoleUpdateResponse: 10523 ''' 10524 RoleUpdateResponse returns the fields of a Role after it has been updated by 10525 a RoleUpdateRequest. 10526 ''' 10527 __slots__ = [ 10528 'meta', 10529 'rate_limit', 10530 'role', 10531 ] 10532 10533 def __init__( 10534 self, 10535 meta=None, 10536 rate_limit=None, 10537 role=None, 10538 ): 10539 self.meta = meta if meta is not None else None 10540 ''' 10541 Reserved for future use. 10542 ''' 10543 self.rate_limit = rate_limit if rate_limit is not None else None 10544 ''' 10545 Rate limit information. 10546 ''' 10547 self.role = role if role is not None else None 10548 ''' 10549 The updated Role. 10550 ''' 10551 10552 def __repr__(self): 10553 return '<sdm.RoleUpdateResponse ' + \ 10554 'meta: ' + repr(self.meta) + ' ' +\ 10555 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 10556 'role: ' + repr(self.role) + ' ' +\ 10557 '>' 10558 10559 def to_dict(self): 10560 return { 10561 'meta': self.meta, 10562 'rate_limit': self.rate_limit, 10563 'role': self.role, 10564 } 10565 10566 @classmethod 10567 def from_dict(cls, d): 10568 return cls( 10569 meta=d.get('meta'), 10570 rate_limit=d.get('rate_limit'), 10571 role=d.get('role'), 10572 ) 10573 10574 10575class SQLServer: 10576 ''' 10577 10578 ''' 10579 __slots__ = [ 10580 'database', 10581 'egress_filter', 10582 'healthy', 10583 'hostname', 10584 'id', 10585 'name', 10586 'override_database', 10587 'password', 10588 'port', 10589 'port_override', 10590 'schema', 10591 'secret_store_id', 10592 'tags', 10593 'username', 10594 ] 10595 10596 def __init__( 10597 self, 10598 database=None, 10599 egress_filter=None, 10600 healthy=None, 10601 hostname=None, 10602 id=None, 10603 name=None, 10604 override_database=None, 10605 password=None, 10606 port=None, 10607 port_override=None, 10608 schema=None, 10609 secret_store_id=None, 10610 tags=None, 10611 username=None, 10612 ): 10613 self.database = database if database is not None else '' 10614 ''' 10615 10616 ''' 10617 self.egress_filter = egress_filter if egress_filter is not None else '' 10618 ''' 10619 A filter applied to the routing logic to pin datasource to nodes. 10620 ''' 10621 self.healthy = healthy if healthy is not None else False 10622 ''' 10623 True if the datasource is reachable and the credentials are valid. 10624 ''' 10625 self.hostname = hostname if hostname is not None else '' 10626 ''' 10627 10628 ''' 10629 self.id = id if id is not None else '' 10630 ''' 10631 Unique identifier of the Resource. 10632 ''' 10633 self.name = name if name is not None else '' 10634 ''' 10635 Unique human-readable name of the Resource. 10636 ''' 10637 self.override_database = override_database if override_database is not None else False 10638 ''' 10639 10640 ''' 10641 self.password = password if password is not None else '' 10642 ''' 10643 10644 ''' 10645 self.port = port if port is not None else 0 10646 ''' 10647 10648 ''' 10649 self.port_override = port_override if port_override is not None else 0 10650 ''' 10651 10652 ''' 10653 self.schema = schema if schema is not None else '' 10654 ''' 10655 10656 ''' 10657 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 10658 ''' 10659 ID of the secret store containing credentials for this resource, if any. 10660 ''' 10661 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 10662 ''' 10663 Tags is a map of key, value pairs. 10664 ''' 10665 self.username = username if username is not None else '' 10666 ''' 10667 10668 ''' 10669 10670 def __repr__(self): 10671 return '<sdm.SQLServer ' + \ 10672 'database: ' + repr(self.database) + ' ' +\ 10673 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 10674 'healthy: ' + repr(self.healthy) + ' ' +\ 10675 'hostname: ' + repr(self.hostname) + ' ' +\ 10676 'id: ' + repr(self.id) + ' ' +\ 10677 'name: ' + repr(self.name) + ' ' +\ 10678 'override_database: ' + repr(self.override_database) + ' ' +\ 10679 'password: ' + repr(self.password) + ' ' +\ 10680 'port: ' + repr(self.port) + ' ' +\ 10681 'port_override: ' + repr(self.port_override) + ' ' +\ 10682 'schema: ' + repr(self.schema) + ' ' +\ 10683 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 10684 'tags: ' + repr(self.tags) + ' ' +\ 10685 'username: ' + repr(self.username) + ' ' +\ 10686 '>' 10687 10688 def to_dict(self): 10689 return { 10690 'database': self.database, 10691 'egress_filter': self.egress_filter, 10692 'healthy': self.healthy, 10693 'hostname': self.hostname, 10694 'id': self.id, 10695 'name': self.name, 10696 'override_database': self.override_database, 10697 'password': self.password, 10698 'port': self.port, 10699 'port_override': self.port_override, 10700 'schema': self.schema, 10701 'secret_store_id': self.secret_store_id, 10702 'tags': self.tags, 10703 'username': self.username, 10704 } 10705 10706 @classmethod 10707 def from_dict(cls, d): 10708 return cls( 10709 database=d.get('database'), 10710 egress_filter=d.get('egress_filter'), 10711 healthy=d.get('healthy'), 10712 hostname=d.get('hostname'), 10713 id=d.get('id'), 10714 name=d.get('name'), 10715 override_database=d.get('override_database'), 10716 password=d.get('password'), 10717 port=d.get('port'), 10718 port_override=d.get('port_override'), 10719 schema=d.get('schema'), 10720 secret_store_id=d.get('secret_store_id'), 10721 tags=d.get('tags'), 10722 username=d.get('username'), 10723 ) 10724 10725 10726class SSH: 10727 ''' 10728 10729 ''' 10730 __slots__ = [ 10731 'allow_deprecated_key_exchanges', 10732 'egress_filter', 10733 'healthy', 10734 'hostname', 10735 'id', 10736 'name', 10737 'port', 10738 'port_forwarding', 10739 'public_key', 10740 'secret_store_id', 10741 'tags', 10742 'username', 10743 ] 10744 10745 def __init__( 10746 self, 10747 allow_deprecated_key_exchanges=None, 10748 egress_filter=None, 10749 healthy=None, 10750 hostname=None, 10751 id=None, 10752 name=None, 10753 port=None, 10754 port_forwarding=None, 10755 public_key=None, 10756 secret_store_id=None, 10757 tags=None, 10758 username=None, 10759 ): 10760 self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False 10761 ''' 10762 10763 ''' 10764 self.egress_filter = egress_filter if egress_filter is not None else '' 10765 ''' 10766 A filter applied to the routing logic to pin datasource to nodes. 10767 ''' 10768 self.healthy = healthy if healthy is not None else False 10769 ''' 10770 True if the datasource is reachable and the credentials are valid. 10771 ''' 10772 self.hostname = hostname if hostname is not None else '' 10773 ''' 10774 10775 ''' 10776 self.id = id if id is not None else '' 10777 ''' 10778 Unique identifier of the Resource. 10779 ''' 10780 self.name = name if name is not None else '' 10781 ''' 10782 Unique human-readable name of the Resource. 10783 ''' 10784 self.port = port if port is not None else 0 10785 ''' 10786 10787 ''' 10788 self.port_forwarding = port_forwarding if port_forwarding is not None else False 10789 ''' 10790 10791 ''' 10792 self.public_key = public_key if public_key is not None else '' 10793 ''' 10794 10795 ''' 10796 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 10797 ''' 10798 ID of the secret store containing credentials for this resource, if any. 10799 ''' 10800 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 10801 ''' 10802 Tags is a map of key, value pairs. 10803 ''' 10804 self.username = username if username is not None else '' 10805 ''' 10806 10807 ''' 10808 10809 def __repr__(self): 10810 return '<sdm.SSH ' + \ 10811 'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\ 10812 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 10813 'healthy: ' + repr(self.healthy) + ' ' +\ 10814 'hostname: ' + repr(self.hostname) + ' ' +\ 10815 'id: ' + repr(self.id) + ' ' +\ 10816 'name: ' + repr(self.name) + ' ' +\ 10817 'port: ' + repr(self.port) + ' ' +\ 10818 'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\ 10819 'public_key: ' + repr(self.public_key) + ' ' +\ 10820 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 10821 'tags: ' + repr(self.tags) + ' ' +\ 10822 'username: ' + repr(self.username) + ' ' +\ 10823 '>' 10824 10825 def to_dict(self): 10826 return { 10827 'allow_deprecated_key_exchanges': 10828 self.allow_deprecated_key_exchanges, 10829 'egress_filter': self.egress_filter, 10830 'healthy': self.healthy, 10831 'hostname': self.hostname, 10832 'id': self.id, 10833 'name': self.name, 10834 'port': self.port, 10835 'port_forwarding': self.port_forwarding, 10836 'public_key': self.public_key, 10837 'secret_store_id': self.secret_store_id, 10838 'tags': self.tags, 10839 'username': self.username, 10840 } 10841 10842 @classmethod 10843 def from_dict(cls, d): 10844 return cls( 10845 allow_deprecated_key_exchanges=d.get( 10846 'allow_deprecated_key_exchanges'), 10847 egress_filter=d.get('egress_filter'), 10848 healthy=d.get('healthy'), 10849 hostname=d.get('hostname'), 10850 id=d.get('id'), 10851 name=d.get('name'), 10852 port=d.get('port'), 10853 port_forwarding=d.get('port_forwarding'), 10854 public_key=d.get('public_key'), 10855 secret_store_id=d.get('secret_store_id'), 10856 tags=d.get('tags'), 10857 username=d.get('username'), 10858 ) 10859 10860 10861class SSHCert: 10862 ''' 10863 10864 ''' 10865 __slots__ = [ 10866 'allow_deprecated_key_exchanges', 10867 'egress_filter', 10868 'healthy', 10869 'hostname', 10870 'id', 10871 'name', 10872 'port', 10873 'port_forwarding', 10874 'secret_store_id', 10875 'tags', 10876 'username', 10877 ] 10878 10879 def __init__( 10880 self, 10881 allow_deprecated_key_exchanges=None, 10882 egress_filter=None, 10883 healthy=None, 10884 hostname=None, 10885 id=None, 10886 name=None, 10887 port=None, 10888 port_forwarding=None, 10889 secret_store_id=None, 10890 tags=None, 10891 username=None, 10892 ): 10893 self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False 10894 ''' 10895 10896 ''' 10897 self.egress_filter = egress_filter if egress_filter is not None else '' 10898 ''' 10899 A filter applied to the routing logic to pin datasource to nodes. 10900 ''' 10901 self.healthy = healthy if healthy is not None else False 10902 ''' 10903 True if the datasource is reachable and the credentials are valid. 10904 ''' 10905 self.hostname = hostname if hostname is not None else '' 10906 ''' 10907 10908 ''' 10909 self.id = id if id is not None else '' 10910 ''' 10911 Unique identifier of the Resource. 10912 ''' 10913 self.name = name if name is not None else '' 10914 ''' 10915 Unique human-readable name of the Resource. 10916 ''' 10917 self.port = port if port is not None else 0 10918 ''' 10919 10920 ''' 10921 self.port_forwarding = port_forwarding if port_forwarding is not None else False 10922 ''' 10923 10924 ''' 10925 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 10926 ''' 10927 ID of the secret store containing credentials for this resource, if any. 10928 ''' 10929 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 10930 ''' 10931 Tags is a map of key, value pairs. 10932 ''' 10933 self.username = username if username is not None else '' 10934 ''' 10935 10936 ''' 10937 10938 def __repr__(self): 10939 return '<sdm.SSHCert ' + \ 10940 'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\ 10941 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 10942 'healthy: ' + repr(self.healthy) + ' ' +\ 10943 'hostname: ' + repr(self.hostname) + ' ' +\ 10944 'id: ' + repr(self.id) + ' ' +\ 10945 'name: ' + repr(self.name) + ' ' +\ 10946 'port: ' + repr(self.port) + ' ' +\ 10947 'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\ 10948 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 10949 'tags: ' + repr(self.tags) + ' ' +\ 10950 'username: ' + repr(self.username) + ' ' +\ 10951 '>' 10952 10953 def to_dict(self): 10954 return { 10955 'allow_deprecated_key_exchanges': 10956 self.allow_deprecated_key_exchanges, 10957 'egress_filter': self.egress_filter, 10958 'healthy': self.healthy, 10959 'hostname': self.hostname, 10960 'id': self.id, 10961 'name': self.name, 10962 'port': self.port, 10963 'port_forwarding': self.port_forwarding, 10964 'secret_store_id': self.secret_store_id, 10965 'tags': self.tags, 10966 'username': self.username, 10967 } 10968 10969 @classmethod 10970 def from_dict(cls, d): 10971 return cls( 10972 allow_deprecated_key_exchanges=d.get( 10973 'allow_deprecated_key_exchanges'), 10974 egress_filter=d.get('egress_filter'), 10975 healthy=d.get('healthy'), 10976 hostname=d.get('hostname'), 10977 id=d.get('id'), 10978 name=d.get('name'), 10979 port=d.get('port'), 10980 port_forwarding=d.get('port_forwarding'), 10981 secret_store_id=d.get('secret_store_id'), 10982 tags=d.get('tags'), 10983 username=d.get('username'), 10984 ) 10985 10986 10987class SSHCustomerKey: 10988 ''' 10989 10990 ''' 10991 __slots__ = [ 10992 'allow_deprecated_key_exchanges', 10993 'egress_filter', 10994 'healthy', 10995 'hostname', 10996 'id', 10997 'name', 10998 'port', 10999 'port_forwarding', 11000 'private_key', 11001 'secret_store_id', 11002 'tags', 11003 'username', 11004 ] 11005 11006 def __init__( 11007 self, 11008 allow_deprecated_key_exchanges=None, 11009 egress_filter=None, 11010 healthy=None, 11011 hostname=None, 11012 id=None, 11013 name=None, 11014 port=None, 11015 port_forwarding=None, 11016 private_key=None, 11017 secret_store_id=None, 11018 tags=None, 11019 username=None, 11020 ): 11021 self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False 11022 ''' 11023 11024 ''' 11025 self.egress_filter = egress_filter if egress_filter is not None else '' 11026 ''' 11027 A filter applied to the routing logic to pin datasource to nodes. 11028 ''' 11029 self.healthy = healthy if healthy is not None else False 11030 ''' 11031 True if the datasource is reachable and the credentials are valid. 11032 ''' 11033 self.hostname = hostname if hostname is not None else '' 11034 ''' 11035 11036 ''' 11037 self.id = id if id is not None else '' 11038 ''' 11039 Unique identifier of the Resource. 11040 ''' 11041 self.name = name if name is not None else '' 11042 ''' 11043 Unique human-readable name of the Resource. 11044 ''' 11045 self.port = port if port is not None else 0 11046 ''' 11047 11048 ''' 11049 self.port_forwarding = port_forwarding if port_forwarding is not None else False 11050 ''' 11051 11052 ''' 11053 self.private_key = private_key if private_key is not None else '' 11054 ''' 11055 11056 ''' 11057 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 11058 ''' 11059 ID of the secret store containing credentials for this resource, if any. 11060 ''' 11061 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 11062 ''' 11063 Tags is a map of key, value pairs. 11064 ''' 11065 self.username = username if username is not None else '' 11066 ''' 11067 11068 ''' 11069 11070 def __repr__(self): 11071 return '<sdm.SSHCustomerKey ' + \ 11072 'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\ 11073 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 11074 'healthy: ' + repr(self.healthy) + ' ' +\ 11075 'hostname: ' + repr(self.hostname) + ' ' +\ 11076 'id: ' + repr(self.id) + ' ' +\ 11077 'name: ' + repr(self.name) + ' ' +\ 11078 'port: ' + repr(self.port) + ' ' +\ 11079 'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\ 11080 'private_key: ' + repr(self.private_key) + ' ' +\ 11081 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 11082 'tags: ' + repr(self.tags) + ' ' +\ 11083 'username: ' + repr(self.username) + ' ' +\ 11084 '>' 11085 11086 def to_dict(self): 11087 return { 11088 'allow_deprecated_key_exchanges': 11089 self.allow_deprecated_key_exchanges, 11090 'egress_filter': self.egress_filter, 11091 'healthy': self.healthy, 11092 'hostname': self.hostname, 11093 'id': self.id, 11094 'name': self.name, 11095 'port': self.port, 11096 'port_forwarding': self.port_forwarding, 11097 'private_key': self.private_key, 11098 'secret_store_id': self.secret_store_id, 11099 'tags': self.tags, 11100 'username': self.username, 11101 } 11102 11103 @classmethod 11104 def from_dict(cls, d): 11105 return cls( 11106 allow_deprecated_key_exchanges=d.get( 11107 'allow_deprecated_key_exchanges'), 11108 egress_filter=d.get('egress_filter'), 11109 healthy=d.get('healthy'), 11110 hostname=d.get('hostname'), 11111 id=d.get('id'), 11112 name=d.get('name'), 11113 port=d.get('port'), 11114 port_forwarding=d.get('port_forwarding'), 11115 private_key=d.get('private_key'), 11116 secret_store_id=d.get('secret_store_id'), 11117 tags=d.get('tags'), 11118 username=d.get('username'), 11119 ) 11120 11121 11122class SecretStoreCreateResponse: 11123 ''' 11124 SecretStoreCreateResponse reports how the SecretStores were created in the system. 11125 ''' 11126 __slots__ = [ 11127 'meta', 11128 'rate_limit', 11129 'secret_store', 11130 ] 11131 11132 def __init__( 11133 self, 11134 meta=None, 11135 rate_limit=None, 11136 secret_store=None, 11137 ): 11138 self.meta = meta if meta is not None else None 11139 ''' 11140 Reserved for future use. 11141 ''' 11142 self.rate_limit = rate_limit if rate_limit is not None else None 11143 ''' 11144 Rate limit information. 11145 ''' 11146 self.secret_store = secret_store if secret_store is not None else None 11147 ''' 11148 The created SecretStore. 11149 ''' 11150 11151 def __repr__(self): 11152 return '<sdm.SecretStoreCreateResponse ' + \ 11153 'meta: ' + repr(self.meta) + ' ' +\ 11154 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 11155 'secret_store: ' + repr(self.secret_store) + ' ' +\ 11156 '>' 11157 11158 def to_dict(self): 11159 return { 11160 'meta': self.meta, 11161 'rate_limit': self.rate_limit, 11162 'secret_store': self.secret_store, 11163 } 11164 11165 @classmethod 11166 def from_dict(cls, d): 11167 return cls( 11168 meta=d.get('meta'), 11169 rate_limit=d.get('rate_limit'), 11170 secret_store=d.get('secret_store'), 11171 ) 11172 11173 11174class SecretStoreDeleteResponse: 11175 ''' 11176 SecretStoreDeleteResponse returns information about a SecretStore that was deleted. 11177 ''' 11178 __slots__ = [ 11179 'meta', 11180 'rate_limit', 11181 ] 11182 11183 def __init__( 11184 self, 11185 meta=None, 11186 rate_limit=None, 11187 ): 11188 self.meta = meta if meta is not None else None 11189 ''' 11190 Reserved for future use. 11191 ''' 11192 self.rate_limit = rate_limit if rate_limit is not None else None 11193 ''' 11194 Rate limit information. 11195 ''' 11196 11197 def __repr__(self): 11198 return '<sdm.SecretStoreDeleteResponse ' + \ 11199 'meta: ' + repr(self.meta) + ' ' +\ 11200 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 11201 '>' 11202 11203 def to_dict(self): 11204 return { 11205 'meta': self.meta, 11206 'rate_limit': self.rate_limit, 11207 } 11208 11209 @classmethod 11210 def from_dict(cls, d): 11211 return cls( 11212 meta=d.get('meta'), 11213 rate_limit=d.get('rate_limit'), 11214 ) 11215 11216 11217class SecretStoreGetResponse: 11218 ''' 11219 SecretStoreGetResponse returns a requested SecretStore. 11220 ''' 11221 __slots__ = [ 11222 'meta', 11223 'rate_limit', 11224 'secret_store', 11225 ] 11226 11227 def __init__( 11228 self, 11229 meta=None, 11230 rate_limit=None, 11231 secret_store=None, 11232 ): 11233 self.meta = meta if meta is not None else None 11234 ''' 11235 Reserved for future use. 11236 ''' 11237 self.rate_limit = rate_limit if rate_limit is not None else None 11238 ''' 11239 Rate limit information. 11240 ''' 11241 self.secret_store = secret_store if secret_store is not None else None 11242 ''' 11243 The requested SecretStore. 11244 ''' 11245 11246 def __repr__(self): 11247 return '<sdm.SecretStoreGetResponse ' + \ 11248 'meta: ' + repr(self.meta) + ' ' +\ 11249 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 11250 'secret_store: ' + repr(self.secret_store) + ' ' +\ 11251 '>' 11252 11253 def to_dict(self): 11254 return { 11255 'meta': self.meta, 11256 'rate_limit': self.rate_limit, 11257 'secret_store': self.secret_store, 11258 } 11259 11260 @classmethod 11261 def from_dict(cls, d): 11262 return cls( 11263 meta=d.get('meta'), 11264 rate_limit=d.get('rate_limit'), 11265 secret_store=d.get('secret_store'), 11266 ) 11267 11268 11269class SecretStoreUpdateResponse: 11270 ''' 11271 SecretStoreUpdateResponse returns the fields of a SecretStore after it has been updated by 11272 a SecretStoreUpdateRequest. 11273 ''' 11274 __slots__ = [ 11275 'meta', 11276 'rate_limit', 11277 'secret_store', 11278 ] 11279 11280 def __init__( 11281 self, 11282 meta=None, 11283 rate_limit=None, 11284 secret_store=None, 11285 ): 11286 self.meta = meta if meta is not None else None 11287 ''' 11288 Reserved for future use. 11289 ''' 11290 self.rate_limit = rate_limit if rate_limit is not None else None 11291 ''' 11292 Rate limit information. 11293 ''' 11294 self.secret_store = secret_store if secret_store is not None else None 11295 ''' 11296 The updated SecretStore. 11297 ''' 11298 11299 def __repr__(self): 11300 return '<sdm.SecretStoreUpdateResponse ' + \ 11301 'meta: ' + repr(self.meta) + ' ' +\ 11302 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 11303 'secret_store: ' + repr(self.secret_store) + ' ' +\ 11304 '>' 11305 11306 def to_dict(self): 11307 return { 11308 'meta': self.meta, 11309 'rate_limit': self.rate_limit, 11310 'secret_store': self.secret_store, 11311 } 11312 11313 @classmethod 11314 def from_dict(cls, d): 11315 return cls( 11316 meta=d.get('meta'), 11317 rate_limit=d.get('rate_limit'), 11318 secret_store=d.get('secret_store'), 11319 ) 11320 11321 11322class Service: 11323 ''' 11324 A Service is a service account that can connect to resources they are granted 11325 directly, or granted via roles. Services are typically automated jobs. 11326 ''' 11327 __slots__ = [ 11328 'id', 11329 'name', 11330 'suspended', 11331 'tags', 11332 ] 11333 11334 def __init__( 11335 self, 11336 id=None, 11337 name=None, 11338 suspended=None, 11339 tags=None, 11340 ): 11341 self.id = id if id is not None else '' 11342 ''' 11343 Unique identifier of the Service. 11344 ''' 11345 self.name = name if name is not None else '' 11346 ''' 11347 Unique human-readable name of the Service. 11348 ''' 11349 self.suspended = suspended if suspended is not None else False 11350 ''' 11351 The Service's suspended state. 11352 ''' 11353 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 11354 ''' 11355 Tags is a map of key, value pairs. 11356 ''' 11357 11358 def __repr__(self): 11359 return '<sdm.Service ' + \ 11360 'id: ' + repr(self.id) + ' ' +\ 11361 'name: ' + repr(self.name) + ' ' +\ 11362 'suspended: ' + repr(self.suspended) + ' ' +\ 11363 'tags: ' + repr(self.tags) + ' ' +\ 11364 '>' 11365 11366 def to_dict(self): 11367 return { 11368 'id': self.id, 11369 'name': self.name, 11370 'suspended': self.suspended, 11371 'tags': self.tags, 11372 } 11373 11374 @classmethod 11375 def from_dict(cls, d): 11376 return cls( 11377 id=d.get('id'), 11378 name=d.get('name'), 11379 suspended=d.get('suspended'), 11380 tags=d.get('tags'), 11381 ) 11382 11383 11384class SingleStore: 11385 ''' 11386 11387 ''' 11388 __slots__ = [ 11389 'database', 11390 'egress_filter', 11391 'healthy', 11392 'hostname', 11393 'id', 11394 'name', 11395 'password', 11396 'port', 11397 'port_override', 11398 'secret_store_id', 11399 'tags', 11400 'username', 11401 ] 11402 11403 def __init__( 11404 self, 11405 database=None, 11406 egress_filter=None, 11407 healthy=None, 11408 hostname=None, 11409 id=None, 11410 name=None, 11411 password=None, 11412 port=None, 11413 port_override=None, 11414 secret_store_id=None, 11415 tags=None, 11416 username=None, 11417 ): 11418 self.database = database if database is not None else '' 11419 ''' 11420 11421 ''' 11422 self.egress_filter = egress_filter if egress_filter is not None else '' 11423 ''' 11424 A filter applied to the routing logic to pin datasource to nodes. 11425 ''' 11426 self.healthy = healthy if healthy is not None else False 11427 ''' 11428 True if the datasource is reachable and the credentials are valid. 11429 ''' 11430 self.hostname = hostname if hostname is not None else '' 11431 ''' 11432 11433 ''' 11434 self.id = id if id is not None else '' 11435 ''' 11436 Unique identifier of the Resource. 11437 ''' 11438 self.name = name if name is not None else '' 11439 ''' 11440 Unique human-readable name of the Resource. 11441 ''' 11442 self.password = password if password is not None else '' 11443 ''' 11444 11445 ''' 11446 self.port = port if port is not None else 0 11447 ''' 11448 11449 ''' 11450 self.port_override = port_override if port_override is not None else 0 11451 ''' 11452 11453 ''' 11454 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 11455 ''' 11456 ID of the secret store containing credentials for this resource, if any. 11457 ''' 11458 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 11459 ''' 11460 Tags is a map of key, value pairs. 11461 ''' 11462 self.username = username if username is not None else '' 11463 ''' 11464 11465 ''' 11466 11467 def __repr__(self): 11468 return '<sdm.SingleStore ' + \ 11469 'database: ' + repr(self.database) + ' ' +\ 11470 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 11471 'healthy: ' + repr(self.healthy) + ' ' +\ 11472 'hostname: ' + repr(self.hostname) + ' ' +\ 11473 'id: ' + repr(self.id) + ' ' +\ 11474 'name: ' + repr(self.name) + ' ' +\ 11475 'password: ' + repr(self.password) + ' ' +\ 11476 'port: ' + repr(self.port) + ' ' +\ 11477 'port_override: ' + repr(self.port_override) + ' ' +\ 11478 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 11479 'tags: ' + repr(self.tags) + ' ' +\ 11480 'username: ' + repr(self.username) + ' ' +\ 11481 '>' 11482 11483 def to_dict(self): 11484 return { 11485 'database': self.database, 11486 'egress_filter': self.egress_filter, 11487 'healthy': self.healthy, 11488 'hostname': self.hostname, 11489 'id': self.id, 11490 'name': self.name, 11491 'password': self.password, 11492 'port': self.port, 11493 'port_override': self.port_override, 11494 'secret_store_id': self.secret_store_id, 11495 'tags': self.tags, 11496 'username': self.username, 11497 } 11498 11499 @classmethod 11500 def from_dict(cls, d): 11501 return cls( 11502 database=d.get('database'), 11503 egress_filter=d.get('egress_filter'), 11504 healthy=d.get('healthy'), 11505 hostname=d.get('hostname'), 11506 id=d.get('id'), 11507 name=d.get('name'), 11508 password=d.get('password'), 11509 port=d.get('port'), 11510 port_override=d.get('port_override'), 11511 secret_store_id=d.get('secret_store_id'), 11512 tags=d.get('tags'), 11513 username=d.get('username'), 11514 ) 11515 11516 11517class Snowflake: 11518 ''' 11519 11520 ''' 11521 __slots__ = [ 11522 'database', 11523 'egress_filter', 11524 'healthy', 11525 'hostname', 11526 'id', 11527 'name', 11528 'password', 11529 'port_override', 11530 'schema', 11531 'secret_store_id', 11532 'tags', 11533 'username', 11534 ] 11535 11536 def __init__( 11537 self, 11538 database=None, 11539 egress_filter=None, 11540 healthy=None, 11541 hostname=None, 11542 id=None, 11543 name=None, 11544 password=None, 11545 port_override=None, 11546 schema=None, 11547 secret_store_id=None, 11548 tags=None, 11549 username=None, 11550 ): 11551 self.database = database if database is not None else '' 11552 ''' 11553 11554 ''' 11555 self.egress_filter = egress_filter if egress_filter is not None else '' 11556 ''' 11557 A filter applied to the routing logic to pin datasource to nodes. 11558 ''' 11559 self.healthy = healthy if healthy is not None else False 11560 ''' 11561 True if the datasource is reachable and the credentials are valid. 11562 ''' 11563 self.hostname = hostname if hostname is not None else '' 11564 ''' 11565 11566 ''' 11567 self.id = id if id is not None else '' 11568 ''' 11569 Unique identifier of the Resource. 11570 ''' 11571 self.name = name if name is not None else '' 11572 ''' 11573 Unique human-readable name of the Resource. 11574 ''' 11575 self.password = password if password is not None else '' 11576 ''' 11577 11578 ''' 11579 self.port_override = port_override if port_override is not None else 0 11580 ''' 11581 11582 ''' 11583 self.schema = schema if schema is not None else '' 11584 ''' 11585 11586 ''' 11587 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 11588 ''' 11589 ID of the secret store containing credentials for this resource, if any. 11590 ''' 11591 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 11592 ''' 11593 Tags is a map of key, value pairs. 11594 ''' 11595 self.username = username if username is not None else '' 11596 ''' 11597 11598 ''' 11599 11600 def __repr__(self): 11601 return '<sdm.Snowflake ' + \ 11602 'database: ' + repr(self.database) + ' ' +\ 11603 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 11604 'healthy: ' + repr(self.healthy) + ' ' +\ 11605 'hostname: ' + repr(self.hostname) + ' ' +\ 11606 'id: ' + repr(self.id) + ' ' +\ 11607 'name: ' + repr(self.name) + ' ' +\ 11608 'password: ' + repr(self.password) + ' ' +\ 11609 'port_override: ' + repr(self.port_override) + ' ' +\ 11610 'schema: ' + repr(self.schema) + ' ' +\ 11611 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 11612 'tags: ' + repr(self.tags) + ' ' +\ 11613 'username: ' + repr(self.username) + ' ' +\ 11614 '>' 11615 11616 def to_dict(self): 11617 return { 11618 'database': self.database, 11619 'egress_filter': self.egress_filter, 11620 'healthy': self.healthy, 11621 'hostname': self.hostname, 11622 'id': self.id, 11623 'name': self.name, 11624 'password': self.password, 11625 'port_override': self.port_override, 11626 'schema': self.schema, 11627 'secret_store_id': self.secret_store_id, 11628 'tags': self.tags, 11629 'username': self.username, 11630 } 11631 11632 @classmethod 11633 def from_dict(cls, d): 11634 return cls( 11635 database=d.get('database'), 11636 egress_filter=d.get('egress_filter'), 11637 healthy=d.get('healthy'), 11638 hostname=d.get('hostname'), 11639 id=d.get('id'), 11640 name=d.get('name'), 11641 password=d.get('password'), 11642 port_override=d.get('port_override'), 11643 schema=d.get('schema'), 11644 secret_store_id=d.get('secret_store_id'), 11645 tags=d.get('tags'), 11646 username=d.get('username'), 11647 ) 11648 11649 11650class Sybase: 11651 ''' 11652 11653 ''' 11654 __slots__ = [ 11655 'egress_filter', 11656 'healthy', 11657 'hostname', 11658 'id', 11659 'name', 11660 'password', 11661 'port', 11662 'port_override', 11663 'secret_store_id', 11664 'tags', 11665 'username', 11666 ] 11667 11668 def __init__( 11669 self, 11670 egress_filter=None, 11671 healthy=None, 11672 hostname=None, 11673 id=None, 11674 name=None, 11675 password=None, 11676 port=None, 11677 port_override=None, 11678 secret_store_id=None, 11679 tags=None, 11680 username=None, 11681 ): 11682 self.egress_filter = egress_filter if egress_filter is not None else '' 11683 ''' 11684 A filter applied to the routing logic to pin datasource to nodes. 11685 ''' 11686 self.healthy = healthy if healthy is not None else False 11687 ''' 11688 True if the datasource is reachable and the credentials are valid. 11689 ''' 11690 self.hostname = hostname if hostname is not None else '' 11691 ''' 11692 11693 ''' 11694 self.id = id if id is not None else '' 11695 ''' 11696 Unique identifier of the Resource. 11697 ''' 11698 self.name = name if name is not None else '' 11699 ''' 11700 Unique human-readable name of the Resource. 11701 ''' 11702 self.password = password if password is not None else '' 11703 ''' 11704 11705 ''' 11706 self.port = port if port is not None else 0 11707 ''' 11708 11709 ''' 11710 self.port_override = port_override if port_override is not None else 0 11711 ''' 11712 11713 ''' 11714 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 11715 ''' 11716 ID of the secret store containing credentials for this resource, if any. 11717 ''' 11718 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 11719 ''' 11720 Tags is a map of key, value pairs. 11721 ''' 11722 self.username = username if username is not None else '' 11723 ''' 11724 11725 ''' 11726 11727 def __repr__(self): 11728 return '<sdm.Sybase ' + \ 11729 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 11730 'healthy: ' + repr(self.healthy) + ' ' +\ 11731 'hostname: ' + repr(self.hostname) + ' ' +\ 11732 'id: ' + repr(self.id) + ' ' +\ 11733 'name: ' + repr(self.name) + ' ' +\ 11734 'password: ' + repr(self.password) + ' ' +\ 11735 'port: ' + repr(self.port) + ' ' +\ 11736 'port_override: ' + repr(self.port_override) + ' ' +\ 11737 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 11738 'tags: ' + repr(self.tags) + ' ' +\ 11739 'username: ' + repr(self.username) + ' ' +\ 11740 '>' 11741 11742 def to_dict(self): 11743 return { 11744 'egress_filter': self.egress_filter, 11745 'healthy': self.healthy, 11746 'hostname': self.hostname, 11747 'id': self.id, 11748 'name': self.name, 11749 'password': self.password, 11750 'port': self.port, 11751 'port_override': self.port_override, 11752 'secret_store_id': self.secret_store_id, 11753 'tags': self.tags, 11754 'username': self.username, 11755 } 11756 11757 @classmethod 11758 def from_dict(cls, d): 11759 return cls( 11760 egress_filter=d.get('egress_filter'), 11761 healthy=d.get('healthy'), 11762 hostname=d.get('hostname'), 11763 id=d.get('id'), 11764 name=d.get('name'), 11765 password=d.get('password'), 11766 port=d.get('port'), 11767 port_override=d.get('port_override'), 11768 secret_store_id=d.get('secret_store_id'), 11769 tags=d.get('tags'), 11770 username=d.get('username'), 11771 ) 11772 11773 11774class SybaseIQ: 11775 ''' 11776 11777 ''' 11778 __slots__ = [ 11779 'egress_filter', 11780 'healthy', 11781 'hostname', 11782 'id', 11783 'name', 11784 'password', 11785 'port', 11786 'port_override', 11787 'secret_store_id', 11788 'tags', 11789 'username', 11790 ] 11791 11792 def __init__( 11793 self, 11794 egress_filter=None, 11795 healthy=None, 11796 hostname=None, 11797 id=None, 11798 name=None, 11799 password=None, 11800 port=None, 11801 port_override=None, 11802 secret_store_id=None, 11803 tags=None, 11804 username=None, 11805 ): 11806 self.egress_filter = egress_filter if egress_filter is not None else '' 11807 ''' 11808 A filter applied to the routing logic to pin datasource to nodes. 11809 ''' 11810 self.healthy = healthy if healthy is not None else False 11811 ''' 11812 True if the datasource is reachable and the credentials are valid. 11813 ''' 11814 self.hostname = hostname if hostname is not None else '' 11815 ''' 11816 11817 ''' 11818 self.id = id if id is not None else '' 11819 ''' 11820 Unique identifier of the Resource. 11821 ''' 11822 self.name = name if name is not None else '' 11823 ''' 11824 Unique human-readable name of the Resource. 11825 ''' 11826 self.password = password if password is not None else '' 11827 ''' 11828 11829 ''' 11830 self.port = port if port is not None else 0 11831 ''' 11832 11833 ''' 11834 self.port_override = port_override if port_override is not None else 0 11835 ''' 11836 11837 ''' 11838 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 11839 ''' 11840 ID of the secret store containing credentials for this resource, if any. 11841 ''' 11842 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 11843 ''' 11844 Tags is a map of key, value pairs. 11845 ''' 11846 self.username = username if username is not None else '' 11847 ''' 11848 11849 ''' 11850 11851 def __repr__(self): 11852 return '<sdm.SybaseIQ ' + \ 11853 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 11854 'healthy: ' + repr(self.healthy) + ' ' +\ 11855 'hostname: ' + repr(self.hostname) + ' ' +\ 11856 'id: ' + repr(self.id) + ' ' +\ 11857 'name: ' + repr(self.name) + ' ' +\ 11858 'password: ' + repr(self.password) + ' ' +\ 11859 'port: ' + repr(self.port) + ' ' +\ 11860 'port_override: ' + repr(self.port_override) + ' ' +\ 11861 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 11862 'tags: ' + repr(self.tags) + ' ' +\ 11863 'username: ' + repr(self.username) + ' ' +\ 11864 '>' 11865 11866 def to_dict(self): 11867 return { 11868 'egress_filter': self.egress_filter, 11869 'healthy': self.healthy, 11870 'hostname': self.hostname, 11871 'id': self.id, 11872 'name': self.name, 11873 'password': self.password, 11874 'port': self.port, 11875 'port_override': self.port_override, 11876 'secret_store_id': self.secret_store_id, 11877 'tags': self.tags, 11878 'username': self.username, 11879 } 11880 11881 @classmethod 11882 def from_dict(cls, d): 11883 return cls( 11884 egress_filter=d.get('egress_filter'), 11885 healthy=d.get('healthy'), 11886 hostname=d.get('hostname'), 11887 id=d.get('id'), 11888 name=d.get('name'), 11889 password=d.get('password'), 11890 port=d.get('port'), 11891 port_override=d.get('port_override'), 11892 secret_store_id=d.get('secret_store_id'), 11893 tags=d.get('tags'), 11894 username=d.get('username'), 11895 ) 11896 11897 11898class Tag: 11899 ''' 11900 11901 ''' 11902 __slots__ = [ 11903 'name', 11904 'value', 11905 ] 11906 11907 def __init__( 11908 self, 11909 name=None, 11910 value=None, 11911 ): 11912 self.name = name if name is not None else '' 11913 ''' 11914 11915 ''' 11916 self.value = value if value is not None else '' 11917 ''' 11918 11919 ''' 11920 11921 def __repr__(self): 11922 return '<sdm.Tag ' + \ 11923 'name: ' + repr(self.name) + ' ' +\ 11924 'value: ' + repr(self.value) + ' ' +\ 11925 '>' 11926 11927 def to_dict(self): 11928 return { 11929 'name': self.name, 11930 'value': self.value, 11931 } 11932 11933 @classmethod 11934 def from_dict(cls, d): 11935 return cls( 11936 name=d.get('name'), 11937 value=d.get('value'), 11938 ) 11939 11940 11941class Teradata: 11942 ''' 11943 11944 ''' 11945 __slots__ = [ 11946 'egress_filter', 11947 'healthy', 11948 'hostname', 11949 'id', 11950 'name', 11951 'password', 11952 'port', 11953 'port_override', 11954 'secret_store_id', 11955 'tags', 11956 'username', 11957 ] 11958 11959 def __init__( 11960 self, 11961 egress_filter=None, 11962 healthy=None, 11963 hostname=None, 11964 id=None, 11965 name=None, 11966 password=None, 11967 port=None, 11968 port_override=None, 11969 secret_store_id=None, 11970 tags=None, 11971 username=None, 11972 ): 11973 self.egress_filter = egress_filter if egress_filter is not None else '' 11974 ''' 11975 A filter applied to the routing logic to pin datasource to nodes. 11976 ''' 11977 self.healthy = healthy if healthy is not None else False 11978 ''' 11979 True if the datasource is reachable and the credentials are valid. 11980 ''' 11981 self.hostname = hostname if hostname is not None else '' 11982 ''' 11983 11984 ''' 11985 self.id = id if id is not None else '' 11986 ''' 11987 Unique identifier of the Resource. 11988 ''' 11989 self.name = name if name is not None else '' 11990 ''' 11991 Unique human-readable name of the Resource. 11992 ''' 11993 self.password = password if password is not None else '' 11994 ''' 11995 11996 ''' 11997 self.port = port if port is not None else 0 11998 ''' 11999 12000 ''' 12001 self.port_override = port_override if port_override is not None else 0 12002 ''' 12003 12004 ''' 12005 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 12006 ''' 12007 ID of the secret store containing credentials for this resource, if any. 12008 ''' 12009 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 12010 ''' 12011 Tags is a map of key, value pairs. 12012 ''' 12013 self.username = username if username is not None else '' 12014 ''' 12015 12016 ''' 12017 12018 def __repr__(self): 12019 return '<sdm.Teradata ' + \ 12020 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 12021 'healthy: ' + repr(self.healthy) + ' ' +\ 12022 'hostname: ' + repr(self.hostname) + ' ' +\ 12023 'id: ' + repr(self.id) + ' ' +\ 12024 'name: ' + repr(self.name) + ' ' +\ 12025 'password: ' + repr(self.password) + ' ' +\ 12026 'port: ' + repr(self.port) + ' ' +\ 12027 'port_override: ' + repr(self.port_override) + ' ' +\ 12028 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 12029 'tags: ' + repr(self.tags) + ' ' +\ 12030 'username: ' + repr(self.username) + ' ' +\ 12031 '>' 12032 12033 def to_dict(self): 12034 return { 12035 'egress_filter': self.egress_filter, 12036 'healthy': self.healthy, 12037 'hostname': self.hostname, 12038 'id': self.id, 12039 'name': self.name, 12040 'password': self.password, 12041 'port': self.port, 12042 'port_override': self.port_override, 12043 'secret_store_id': self.secret_store_id, 12044 'tags': self.tags, 12045 'username': self.username, 12046 } 12047 12048 @classmethod 12049 def from_dict(cls, d): 12050 return cls( 12051 egress_filter=d.get('egress_filter'), 12052 healthy=d.get('healthy'), 12053 hostname=d.get('hostname'), 12054 id=d.get('id'), 12055 name=d.get('name'), 12056 password=d.get('password'), 12057 port=d.get('port'), 12058 port_override=d.get('port_override'), 12059 secret_store_id=d.get('secret_store_id'), 12060 tags=d.get('tags'), 12061 username=d.get('username'), 12062 ) 12063 12064 12065class UpdateResponseMetadata: 12066 ''' 12067 UpdateResponseMetadata is reserved for future use. 12068 ''' 12069 __slots__ = [] 12070 12071 def __init__(self, ): 12072 pass 12073 12074 def __repr__(self): 12075 return '<sdm.UpdateResponseMetadata ' + \ 12076 '>' 12077 12078 def to_dict(self): 12079 return {} 12080 12081 @classmethod 12082 def from_dict(cls, d): 12083 return cls() 12084 12085 12086class User: 12087 ''' 12088 A User can connect to resources they are granted directly, or granted 12089 via roles. 12090 ''' 12091 __slots__ = [ 12092 'email', 12093 'first_name', 12094 'id', 12095 'last_name', 12096 'suspended', 12097 'tags', 12098 ] 12099 12100 def __init__( 12101 self, 12102 email=None, 12103 first_name=None, 12104 id=None, 12105 last_name=None, 12106 suspended=None, 12107 tags=None, 12108 ): 12109 self.email = email if email is not None else '' 12110 ''' 12111 The User's email address. Must be unique. 12112 ''' 12113 self.first_name = first_name if first_name is not None else '' 12114 ''' 12115 The User's first name. 12116 ''' 12117 self.id = id if id is not None else '' 12118 ''' 12119 Unique identifier of the User. 12120 ''' 12121 self.last_name = last_name if last_name is not None else '' 12122 ''' 12123 The User's last name. 12124 ''' 12125 self.suspended = suspended if suspended is not None else False 12126 ''' 12127 The User's suspended state. 12128 ''' 12129 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 12130 ''' 12131 Tags is a map of key, value pairs. 12132 ''' 12133 12134 def __repr__(self): 12135 return '<sdm.User ' + \ 12136 'email: ' + repr(self.email) + ' ' +\ 12137 'first_name: ' + repr(self.first_name) + ' ' +\ 12138 'id: ' + repr(self.id) + ' ' +\ 12139 'last_name: ' + repr(self.last_name) + ' ' +\ 12140 'suspended: ' + repr(self.suspended) + ' ' +\ 12141 'tags: ' + repr(self.tags) + ' ' +\ 12142 '>' 12143 12144 def to_dict(self): 12145 return { 12146 'email': self.email, 12147 'first_name': self.first_name, 12148 'id': self.id, 12149 'last_name': self.last_name, 12150 'suspended': self.suspended, 12151 'tags': self.tags, 12152 } 12153 12154 @classmethod 12155 def from_dict(cls, d): 12156 return cls( 12157 email=d.get('email'), 12158 first_name=d.get('first_name'), 12159 id=d.get('id'), 12160 last_name=d.get('last_name'), 12161 suspended=d.get('suspended'), 12162 tags=d.get('tags'), 12163 ) 12164 12165 12166class VaultAppRoleStore: 12167 ''' 12168 12169 ''' 12170 __slots__ = [ 12171 'id', 12172 'name', 12173 'namespace', 12174 'server_address', 12175 'tags', 12176 ] 12177 12178 def __init__( 12179 self, 12180 id=None, 12181 name=None, 12182 namespace=None, 12183 server_address=None, 12184 tags=None, 12185 ): 12186 self.id = id if id is not None else '' 12187 ''' 12188 Unique identifier of the SecretStore. 12189 ''' 12190 self.name = name if name is not None else '' 12191 ''' 12192 Unique human-readable name of the SecretStore. 12193 ''' 12194 self.namespace = namespace if namespace is not None else '' 12195 ''' 12196 12197 ''' 12198 self.server_address = server_address if server_address is not None else '' 12199 ''' 12200 12201 ''' 12202 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 12203 ''' 12204 Tags is a map of key, value pairs. 12205 ''' 12206 12207 def __repr__(self): 12208 return '<sdm.VaultAppRoleStore ' + \ 12209 'id: ' + repr(self.id) + ' ' +\ 12210 'name: ' + repr(self.name) + ' ' +\ 12211 'namespace: ' + repr(self.namespace) + ' ' +\ 12212 'server_address: ' + repr(self.server_address) + ' ' +\ 12213 'tags: ' + repr(self.tags) + ' ' +\ 12214 '>' 12215 12216 def to_dict(self): 12217 return { 12218 'id': self.id, 12219 'name': self.name, 12220 'namespace': self.namespace, 12221 'server_address': self.server_address, 12222 'tags': self.tags, 12223 } 12224 12225 @classmethod 12226 def from_dict(cls, d): 12227 return cls( 12228 id=d.get('id'), 12229 name=d.get('name'), 12230 namespace=d.get('namespace'), 12231 server_address=d.get('server_address'), 12232 tags=d.get('tags'), 12233 ) 12234 12235 12236class VaultTLSStore: 12237 ''' 12238 12239 ''' 12240 __slots__ = [ 12241 'ca_cert_path', 12242 'client_cert_path', 12243 'client_key_path', 12244 'id', 12245 'name', 12246 'namespace', 12247 'server_address', 12248 'tags', 12249 ] 12250 12251 def __init__( 12252 self, 12253 ca_cert_path=None, 12254 client_cert_path=None, 12255 client_key_path=None, 12256 id=None, 12257 name=None, 12258 namespace=None, 12259 server_address=None, 12260 tags=None, 12261 ): 12262 self.ca_cert_path = ca_cert_path if ca_cert_path is not None else '' 12263 ''' 12264 12265 ''' 12266 self.client_cert_path = client_cert_path if client_cert_path is not None else '' 12267 ''' 12268 12269 ''' 12270 self.client_key_path = client_key_path if client_key_path is not None else '' 12271 ''' 12272 12273 ''' 12274 self.id = id if id is not None else '' 12275 ''' 12276 Unique identifier of the SecretStore. 12277 ''' 12278 self.name = name if name is not None else '' 12279 ''' 12280 Unique human-readable name of the SecretStore. 12281 ''' 12282 self.namespace = namespace if namespace is not None else '' 12283 ''' 12284 12285 ''' 12286 self.server_address = server_address if server_address is not None else '' 12287 ''' 12288 12289 ''' 12290 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 12291 ''' 12292 Tags is a map of key, value pairs. 12293 ''' 12294 12295 def __repr__(self): 12296 return '<sdm.VaultTLSStore ' + \ 12297 'ca_cert_path: ' + repr(self.ca_cert_path) + ' ' +\ 12298 'client_cert_path: ' + repr(self.client_cert_path) + ' ' +\ 12299 'client_key_path: ' + repr(self.client_key_path) + ' ' +\ 12300 'id: ' + repr(self.id) + ' ' +\ 12301 'name: ' + repr(self.name) + ' ' +\ 12302 'namespace: ' + repr(self.namespace) + ' ' +\ 12303 'server_address: ' + repr(self.server_address) + ' ' +\ 12304 'tags: ' + repr(self.tags) + ' ' +\ 12305 '>' 12306 12307 def to_dict(self): 12308 return { 12309 'ca_cert_path': self.ca_cert_path, 12310 'client_cert_path': self.client_cert_path, 12311 'client_key_path': self.client_key_path, 12312 'id': self.id, 12313 'name': self.name, 12314 'namespace': self.namespace, 12315 'server_address': self.server_address, 12316 'tags': self.tags, 12317 } 12318 12319 @classmethod 12320 def from_dict(cls, d): 12321 return cls( 12322 ca_cert_path=d.get('ca_cert_path'), 12323 client_cert_path=d.get('client_cert_path'), 12324 client_key_path=d.get('client_key_path'), 12325 id=d.get('id'), 12326 name=d.get('name'), 12327 namespace=d.get('namespace'), 12328 server_address=d.get('server_address'), 12329 tags=d.get('tags'), 12330 ) 12331 12332 12333class VaultTokenStore: 12334 ''' 12335 12336 ''' 12337 __slots__ = [ 12338 'id', 12339 'name', 12340 'namespace', 12341 'server_address', 12342 'tags', 12343 ] 12344 12345 def __init__( 12346 self, 12347 id=None, 12348 name=None, 12349 namespace=None, 12350 server_address=None, 12351 tags=None, 12352 ): 12353 self.id = id if id is not None else '' 12354 ''' 12355 Unique identifier of the SecretStore. 12356 ''' 12357 self.name = name if name is not None else '' 12358 ''' 12359 Unique human-readable name of the SecretStore. 12360 ''' 12361 self.namespace = namespace if namespace is not None else '' 12362 ''' 12363 12364 ''' 12365 self.server_address = server_address if server_address is not None else '' 12366 ''' 12367 12368 ''' 12369 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 12370 ''' 12371 Tags is a map of key, value pairs. 12372 ''' 12373 12374 def __repr__(self): 12375 return '<sdm.VaultTokenStore ' + \ 12376 'id: ' + repr(self.id) + ' ' +\ 12377 'name: ' + repr(self.name) + ' ' +\ 12378 'namespace: ' + repr(self.namespace) + ' ' +\ 12379 'server_address: ' + repr(self.server_address) + ' ' +\ 12380 'tags: ' + repr(self.tags) + ' ' +\ 12381 '>' 12382 12383 def to_dict(self): 12384 return { 12385 'id': self.id, 12386 'name': self.name, 12387 'namespace': self.namespace, 12388 'server_address': self.server_address, 12389 'tags': self.tags, 12390 } 12391 12392 @classmethod 12393 def from_dict(cls, d): 12394 return cls( 12395 id=d.get('id'), 12396 name=d.get('name'), 12397 namespace=d.get('namespace'), 12398 server_address=d.get('server_address'), 12399 tags=d.get('tags'), 12400 ) 12401 12402 12403def _porcelain_zero_value_tags(): 12404 return {} 12405 12406 12407def _porcelain_zero_value_access_rules(): 12408 return []
View Source
21class AKS: 22 ''' 23 24 ''' 25 __slots__ = [ 26 'certificate_authority', 27 'client_certificate', 28 'client_key', 29 'egress_filter', 30 'healthcheck_namespace', 31 'healthy', 32 'hostname', 33 'id', 34 'name', 35 'port', 36 'secret_store_id', 37 'tags', 38 ] 39 40 def __init__( 41 self, 42 certificate_authority=None, 43 client_certificate=None, 44 client_key=None, 45 egress_filter=None, 46 healthcheck_namespace=None, 47 healthy=None, 48 hostname=None, 49 id=None, 50 name=None, 51 port=None, 52 secret_store_id=None, 53 tags=None, 54 ): 55 self.certificate_authority = certificate_authority if certificate_authority is not None else '' 56 ''' 57 58 ''' 59 self.client_certificate = client_certificate if client_certificate is not None else '' 60 ''' 61 62 ''' 63 self.client_key = client_key if client_key is not None else '' 64 ''' 65 66 ''' 67 self.egress_filter = egress_filter if egress_filter is not None else '' 68 ''' 69 A filter applied to the routing logic to pin datasource to nodes. 70 ''' 71 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 72 ''' 73 The path used to check the health of your connection. Defaults to `default`. 74 ''' 75 self.healthy = healthy if healthy is not None else False 76 ''' 77 True if the datasource is reachable and the credentials are valid. 78 ''' 79 self.hostname = hostname if hostname is not None else '' 80 ''' 81 82 ''' 83 self.id = id if id is not None else '' 84 ''' 85 Unique identifier of the Resource. 86 ''' 87 self.name = name if name is not None else '' 88 ''' 89 Unique human-readable name of the Resource. 90 ''' 91 self.port = port if port is not None else 0 92 ''' 93 94 ''' 95 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 96 ''' 97 ID of the secret store containing credentials for this resource, if any. 98 ''' 99 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 100 ''' 101 Tags is a map of key, value pairs. 102 ''' 103 104 def __repr__(self): 105 return '<sdm.AKS ' + \ 106 'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\ 107 'client_certificate: ' + repr(self.client_certificate) + ' ' +\ 108 'client_key: ' + repr(self.client_key) + ' ' +\ 109 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 110 'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\ 111 'healthy: ' + repr(self.healthy) + ' ' +\ 112 'hostname: ' + repr(self.hostname) + ' ' +\ 113 'id: ' + repr(self.id) + ' ' +\ 114 'name: ' + repr(self.name) + ' ' +\ 115 'port: ' + repr(self.port) + ' ' +\ 116 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 117 'tags: ' + repr(self.tags) + ' ' +\ 118 '>' 119 120 def to_dict(self): 121 return { 122 'certificate_authority': self.certificate_authority, 123 'client_certificate': self.client_certificate, 124 'client_key': self.client_key, 125 'egress_filter': self.egress_filter, 126 'healthcheck_namespace': self.healthcheck_namespace, 127 'healthy': self.healthy, 128 'hostname': self.hostname, 129 'id': self.id, 130 'name': self.name, 131 'port': self.port, 132 'secret_store_id': self.secret_store_id, 133 'tags': self.tags, 134 } 135 136 @classmethod 137 def from_dict(cls, d): 138 return cls( 139 certificate_authority=d.get('certificate_authority'), 140 client_certificate=d.get('client_certificate'), 141 client_key=d.get('client_key'), 142 egress_filter=d.get('egress_filter'), 143 healthcheck_namespace=d.get('healthcheck_namespace'), 144 healthy=d.get('healthy'), 145 hostname=d.get('hostname'), 146 id=d.get('id'), 147 name=d.get('name'), 148 port=d.get('port'), 149 secret_store_id=d.get('secret_store_id'), 150 tags=d.get('tags'), 151 )
#
AKS(
certificate_authority=None,
client_certificate=None,
client_key=None,
egress_filter=None,
healthcheck_namespace=None,
healthy=None,
hostname=None,
id=None,
name=None,
port=None,
secret_store_id=None,
tags=None
)
View Source
40 def __init__( 41 self, 42 certificate_authority=None, 43 client_certificate=None, 44 client_key=None, 45 egress_filter=None, 46 healthcheck_namespace=None, 47 healthy=None, 48 hostname=None, 49 id=None, 50 name=None, 51 port=None, 52 secret_store_id=None, 53 tags=None, 54 ): 55 self.certificate_authority = certificate_authority if certificate_authority is not None else '' 56 ''' 57 58 ''' 59 self.client_certificate = client_certificate if client_certificate is not None else '' 60 ''' 61 62 ''' 63 self.client_key = client_key if client_key is not None else '' 64 ''' 65 66 ''' 67 self.egress_filter = egress_filter if egress_filter is not None else '' 68 ''' 69 A filter applied to the routing logic to pin datasource to nodes. 70 ''' 71 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 72 ''' 73 The path used to check the health of your connection. Defaults to `default`. 74 ''' 75 self.healthy = healthy if healthy is not None else False 76 ''' 77 True if the datasource is reachable and the credentials are valid. 78 ''' 79 self.hostname = hostname if hostname is not None else '' 80 ''' 81 82 ''' 83 self.id = id if id is not None else '' 84 ''' 85 Unique identifier of the Resource. 86 ''' 87 self.name = name if name is not None else '' 88 ''' 89 Unique human-readable name of the Resource. 90 ''' 91 self.port = port if port is not None else 0 92 ''' 93 94 ''' 95 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 96 ''' 97 ID of the secret store containing credentials for this resource, if any. 98 ''' 99 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 100 ''' 101 Tags is a map of key, value pairs. 102 '''
#
client_certificate
#
client_key
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthcheck_namespace
The path used to check the health of your connection. Defaults to default.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
port
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
View Source
120 def to_dict(self): 121 return { 122 'certificate_authority': self.certificate_authority, 123 'client_certificate': self.client_certificate, 124 'client_key': self.client_key, 125 'egress_filter': self.egress_filter, 126 'healthcheck_namespace': self.healthcheck_namespace, 127 'healthy': self.healthy, 128 'hostname': self.hostname, 129 'id': self.id, 130 'name': self.name, 131 'port': self.port, 132 'secret_store_id': self.secret_store_id, 133 'tags': self.tags, 134 }
View Source
136 @classmethod 137 def from_dict(cls, d): 138 return cls( 139 certificate_authority=d.get('certificate_authority'), 140 client_certificate=d.get('client_certificate'), 141 client_key=d.get('client_key'), 142 egress_filter=d.get('egress_filter'), 143 healthcheck_namespace=d.get('healthcheck_namespace'), 144 healthy=d.get('healthy'), 145 hostname=d.get('hostname'), 146 id=d.get('id'), 147 name=d.get('name'), 148 port=d.get('port'), 149 secret_store_id=d.get('secret_store_id'), 150 tags=d.get('tags'), 151 )
View Source
154class AKSBasicAuth: 155 ''' 156 157 ''' 158 __slots__ = [ 159 'egress_filter', 160 'healthcheck_namespace', 161 'healthy', 162 'hostname', 163 'id', 164 'name', 165 'password', 166 'port', 167 'secret_store_id', 168 'tags', 169 'username', 170 ] 171 172 def __init__( 173 self, 174 egress_filter=None, 175 healthcheck_namespace=None, 176 healthy=None, 177 hostname=None, 178 id=None, 179 name=None, 180 password=None, 181 port=None, 182 secret_store_id=None, 183 tags=None, 184 username=None, 185 ): 186 self.egress_filter = egress_filter if egress_filter is not None else '' 187 ''' 188 A filter applied to the routing logic to pin datasource to nodes. 189 ''' 190 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 191 ''' 192 The path used to check the health of your connection. Defaults to `default`. 193 ''' 194 self.healthy = healthy if healthy is not None else False 195 ''' 196 True if the datasource is reachable and the credentials are valid. 197 ''' 198 self.hostname = hostname if hostname is not None else '' 199 ''' 200 201 ''' 202 self.id = id if id is not None else '' 203 ''' 204 Unique identifier of the Resource. 205 ''' 206 self.name = name if name is not None else '' 207 ''' 208 Unique human-readable name of the Resource. 209 ''' 210 self.password = password if password is not None else '' 211 ''' 212 213 ''' 214 self.port = port if port is not None else 0 215 ''' 216 217 ''' 218 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 219 ''' 220 ID of the secret store containing credentials for this resource, if any. 221 ''' 222 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 223 ''' 224 Tags is a map of key, value pairs. 225 ''' 226 self.username = username if username is not None else '' 227 ''' 228 229 ''' 230 231 def __repr__(self): 232 return '<sdm.AKSBasicAuth ' + \ 233 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 234 'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\ 235 'healthy: ' + repr(self.healthy) + ' ' +\ 236 'hostname: ' + repr(self.hostname) + ' ' +\ 237 'id: ' + repr(self.id) + ' ' +\ 238 'name: ' + repr(self.name) + ' ' +\ 239 'password: ' + repr(self.password) + ' ' +\ 240 'port: ' + repr(self.port) + ' ' +\ 241 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 242 'tags: ' + repr(self.tags) + ' ' +\ 243 'username: ' + repr(self.username) + ' ' +\ 244 '>' 245 246 def to_dict(self): 247 return { 248 'egress_filter': self.egress_filter, 249 'healthcheck_namespace': self.healthcheck_namespace, 250 'healthy': self.healthy, 251 'hostname': self.hostname, 252 'id': self.id, 253 'name': self.name, 254 'password': self.password, 255 'port': self.port, 256 'secret_store_id': self.secret_store_id, 257 'tags': self.tags, 258 'username': self.username, 259 } 260 261 @classmethod 262 def from_dict(cls, d): 263 return cls( 264 egress_filter=d.get('egress_filter'), 265 healthcheck_namespace=d.get('healthcheck_namespace'), 266 healthy=d.get('healthy'), 267 hostname=d.get('hostname'), 268 id=d.get('id'), 269 name=d.get('name'), 270 password=d.get('password'), 271 port=d.get('port'), 272 secret_store_id=d.get('secret_store_id'), 273 tags=d.get('tags'), 274 username=d.get('username'), 275 )
#
AKSBasicAuth(
egress_filter=None,
healthcheck_namespace=None,
healthy=None,
hostname=None,
id=None,
name=None,
password=None,
port=None,
secret_store_id=None,
tags=None,
username=None
)
View Source
172 def __init__( 173 self, 174 egress_filter=None, 175 healthcheck_namespace=None, 176 healthy=None, 177 hostname=None, 178 id=None, 179 name=None, 180 password=None, 181 port=None, 182 secret_store_id=None, 183 tags=None, 184 username=None, 185 ): 186 self.egress_filter = egress_filter if egress_filter is not None else '' 187 ''' 188 A filter applied to the routing logic to pin datasource to nodes. 189 ''' 190 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 191 ''' 192 The path used to check the health of your connection. Defaults to `default`. 193 ''' 194 self.healthy = healthy if healthy is not None else False 195 ''' 196 True if the datasource is reachable and the credentials are valid. 197 ''' 198 self.hostname = hostname if hostname is not None else '' 199 ''' 200 201 ''' 202 self.id = id if id is not None else '' 203 ''' 204 Unique identifier of the Resource. 205 ''' 206 self.name = name if name is not None else '' 207 ''' 208 Unique human-readable name of the Resource. 209 ''' 210 self.password = password if password is not None else '' 211 ''' 212 213 ''' 214 self.port = port if port is not None else 0 215 ''' 216 217 ''' 218 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 219 ''' 220 ID of the secret store containing credentials for this resource, if any. 221 ''' 222 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 223 ''' 224 Tags is a map of key, value pairs. 225 ''' 226 self.username = username if username is not None else '' 227 ''' 228 229 '''
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthcheck_namespace
The path used to check the health of your connection. Defaults to default.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
password
#
port
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
username
View Source
246 def to_dict(self): 247 return { 248 'egress_filter': self.egress_filter, 249 'healthcheck_namespace': self.healthcheck_namespace, 250 'healthy': self.healthy, 251 'hostname': self.hostname, 252 'id': self.id, 253 'name': self.name, 254 'password': self.password, 255 'port': self.port, 256 'secret_store_id': self.secret_store_id, 257 'tags': self.tags, 258 'username': self.username, 259 }
View Source
261 @classmethod 262 def from_dict(cls, d): 263 return cls( 264 egress_filter=d.get('egress_filter'), 265 healthcheck_namespace=d.get('healthcheck_namespace'), 266 healthy=d.get('healthy'), 267 hostname=d.get('hostname'), 268 id=d.get('id'), 269 name=d.get('name'), 270 password=d.get('password'), 271 port=d.get('port'), 272 secret_store_id=d.get('secret_store_id'), 273 tags=d.get('tags'), 274 username=d.get('username'), 275 )
View Source
278class AKSServiceAccount: 279 ''' 280 281 ''' 282 __slots__ = [ 283 'egress_filter', 284 'healthcheck_namespace', 285 'healthy', 286 'hostname', 287 'id', 288 'name', 289 'port', 290 'secret_store_id', 291 'tags', 292 'token', 293 ] 294 295 def __init__( 296 self, 297 egress_filter=None, 298 healthcheck_namespace=None, 299 healthy=None, 300 hostname=None, 301 id=None, 302 name=None, 303 port=None, 304 secret_store_id=None, 305 tags=None, 306 token=None, 307 ): 308 self.egress_filter = egress_filter if egress_filter is not None else '' 309 ''' 310 A filter applied to the routing logic to pin datasource to nodes. 311 ''' 312 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 313 ''' 314 The path used to check the health of your connection. Defaults to `default`. 315 ''' 316 self.healthy = healthy if healthy is not None else False 317 ''' 318 True if the datasource is reachable and the credentials are valid. 319 ''' 320 self.hostname = hostname if hostname is not None else '' 321 ''' 322 323 ''' 324 self.id = id if id is not None else '' 325 ''' 326 Unique identifier of the Resource. 327 ''' 328 self.name = name if name is not None else '' 329 ''' 330 Unique human-readable name of the Resource. 331 ''' 332 self.port = port if port is not None else 0 333 ''' 334 335 ''' 336 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 337 ''' 338 ID of the secret store containing credentials for this resource, if any. 339 ''' 340 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 341 ''' 342 Tags is a map of key, value pairs. 343 ''' 344 self.token = token if token is not None else '' 345 ''' 346 347 ''' 348 349 def __repr__(self): 350 return '<sdm.AKSServiceAccount ' + \ 351 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 352 'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\ 353 'healthy: ' + repr(self.healthy) + ' ' +\ 354 'hostname: ' + repr(self.hostname) + ' ' +\ 355 'id: ' + repr(self.id) + ' ' +\ 356 'name: ' + repr(self.name) + ' ' +\ 357 'port: ' + repr(self.port) + ' ' +\ 358 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 359 'tags: ' + repr(self.tags) + ' ' +\ 360 'token: ' + repr(self.token) + ' ' +\ 361 '>' 362 363 def to_dict(self): 364 return { 365 'egress_filter': self.egress_filter, 366 'healthcheck_namespace': self.healthcheck_namespace, 367 'healthy': self.healthy, 368 'hostname': self.hostname, 369 'id': self.id, 370 'name': self.name, 371 'port': self.port, 372 'secret_store_id': self.secret_store_id, 373 'tags': self.tags, 374 'token': self.token, 375 } 376 377 @classmethod 378 def from_dict(cls, d): 379 return cls( 380 egress_filter=d.get('egress_filter'), 381 healthcheck_namespace=d.get('healthcheck_namespace'), 382 healthy=d.get('healthy'), 383 hostname=d.get('hostname'), 384 id=d.get('id'), 385 name=d.get('name'), 386 port=d.get('port'), 387 secret_store_id=d.get('secret_store_id'), 388 tags=d.get('tags'), 389 token=d.get('token'), 390 )
#
AKSServiceAccount(
egress_filter=None,
healthcheck_namespace=None,
healthy=None,
hostname=None,
id=None,
name=None,
port=None,
secret_store_id=None,
tags=None,
token=None
)
View Source
295 def __init__( 296 self, 297 egress_filter=None, 298 healthcheck_namespace=None, 299 healthy=None, 300 hostname=None, 301 id=None, 302 name=None, 303 port=None, 304 secret_store_id=None, 305 tags=None, 306 token=None, 307 ): 308 self.egress_filter = egress_filter if egress_filter is not None else '' 309 ''' 310 A filter applied to the routing logic to pin datasource to nodes. 311 ''' 312 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 313 ''' 314 The path used to check the health of your connection. Defaults to `default`. 315 ''' 316 self.healthy = healthy if healthy is not None else False 317 ''' 318 True if the datasource is reachable and the credentials are valid. 319 ''' 320 self.hostname = hostname if hostname is not None else '' 321 ''' 322 323 ''' 324 self.id = id if id is not None else '' 325 ''' 326 Unique identifier of the Resource. 327 ''' 328 self.name = name if name is not None else '' 329 ''' 330 Unique human-readable name of the Resource. 331 ''' 332 self.port = port if port is not None else 0 333 ''' 334 335 ''' 336 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 337 ''' 338 ID of the secret store containing credentials for this resource, if any. 339 ''' 340 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 341 ''' 342 Tags is a map of key, value pairs. 343 ''' 344 self.token = token if token is not None else '' 345 ''' 346 347 '''
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthcheck_namespace
The path used to check the health of your connection. Defaults to default.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
port
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
token
View Source
363 def to_dict(self): 364 return { 365 'egress_filter': self.egress_filter, 366 'healthcheck_namespace': self.healthcheck_namespace, 367 'healthy': self.healthy, 368 'hostname': self.hostname, 369 'id': self.id, 370 'name': self.name, 371 'port': self.port, 372 'secret_store_id': self.secret_store_id, 373 'tags': self.tags, 374 'token': self.token, 375 }
View Source
377 @classmethod 378 def from_dict(cls, d): 379 return cls( 380 egress_filter=d.get('egress_filter'), 381 healthcheck_namespace=d.get('healthcheck_namespace'), 382 healthy=d.get('healthy'), 383 hostname=d.get('hostname'), 384 id=d.get('id'), 385 name=d.get('name'), 386 port=d.get('port'), 387 secret_store_id=d.get('secret_store_id'), 388 tags=d.get('tags'), 389 token=d.get('token'), 390 )
View Source
393class AKSServiceAccountUserImpersonation: 394 ''' 395 396 ''' 397 __slots__ = [ 398 'egress_filter', 399 'healthcheck_namespace', 400 'healthy', 401 'hostname', 402 'id', 403 'name', 404 'port', 405 'secret_store_id', 406 'tags', 407 'token', 408 ] 409 410 def __init__( 411 self, 412 egress_filter=None, 413 healthcheck_namespace=None, 414 healthy=None, 415 hostname=None, 416 id=None, 417 name=None, 418 port=None, 419 secret_store_id=None, 420 tags=None, 421 token=None, 422 ): 423 self.egress_filter = egress_filter if egress_filter is not None else '' 424 ''' 425 A filter applied to the routing logic to pin datasource to nodes. 426 ''' 427 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 428 ''' 429 The path used to check the health of your connection. Defaults to `default`. 430 ''' 431 self.healthy = healthy if healthy is not None else False 432 ''' 433 True if the datasource is reachable and the credentials are valid. 434 ''' 435 self.hostname = hostname if hostname is not None else '' 436 ''' 437 438 ''' 439 self.id = id if id is not None else '' 440 ''' 441 Unique identifier of the Resource. 442 ''' 443 self.name = name if name is not None else '' 444 ''' 445 Unique human-readable name of the Resource. 446 ''' 447 self.port = port if port is not None else 0 448 ''' 449 450 ''' 451 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 452 ''' 453 ID of the secret store containing credentials for this resource, if any. 454 ''' 455 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 456 ''' 457 Tags is a map of key, value pairs. 458 ''' 459 self.token = token if token is not None else '' 460 ''' 461 462 ''' 463 464 def __repr__(self): 465 return '<sdm.AKSServiceAccountUserImpersonation ' + \ 466 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 467 'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\ 468 'healthy: ' + repr(self.healthy) + ' ' +\ 469 'hostname: ' + repr(self.hostname) + ' ' +\ 470 'id: ' + repr(self.id) + ' ' +\ 471 'name: ' + repr(self.name) + ' ' +\ 472 'port: ' + repr(self.port) + ' ' +\ 473 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 474 'tags: ' + repr(self.tags) + ' ' +\ 475 'token: ' + repr(self.token) + ' ' +\ 476 '>' 477 478 def to_dict(self): 479 return { 480 'egress_filter': self.egress_filter, 481 'healthcheck_namespace': self.healthcheck_namespace, 482 'healthy': self.healthy, 483 'hostname': self.hostname, 484 'id': self.id, 485 'name': self.name, 486 'port': self.port, 487 'secret_store_id': self.secret_store_id, 488 'tags': self.tags, 489 'token': self.token, 490 } 491 492 @classmethod 493 def from_dict(cls, d): 494 return cls( 495 egress_filter=d.get('egress_filter'), 496 healthcheck_namespace=d.get('healthcheck_namespace'), 497 healthy=d.get('healthy'), 498 hostname=d.get('hostname'), 499 id=d.get('id'), 500 name=d.get('name'), 501 port=d.get('port'), 502 secret_store_id=d.get('secret_store_id'), 503 tags=d.get('tags'), 504 token=d.get('token'), 505 )
#
AKSServiceAccountUserImpersonation(
egress_filter=None,
healthcheck_namespace=None,
healthy=None,
hostname=None,
id=None,
name=None,
port=None,
secret_store_id=None,
tags=None,
token=None
)
View Source
410 def __init__( 411 self, 412 egress_filter=None, 413 healthcheck_namespace=None, 414 healthy=None, 415 hostname=None, 416 id=None, 417 name=None, 418 port=None, 419 secret_store_id=None, 420 tags=None, 421 token=None, 422 ): 423 self.egress_filter = egress_filter if egress_filter is not None else '' 424 ''' 425 A filter applied to the routing logic to pin datasource to nodes. 426 ''' 427 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 428 ''' 429 The path used to check the health of your connection. Defaults to `default`. 430 ''' 431 self.healthy = healthy if healthy is not None else False 432 ''' 433 True if the datasource is reachable and the credentials are valid. 434 ''' 435 self.hostname = hostname if hostname is not None else '' 436 ''' 437 438 ''' 439 self.id = id if id is not None else '' 440 ''' 441 Unique identifier of the Resource. 442 ''' 443 self.name = name if name is not None else '' 444 ''' 445 Unique human-readable name of the Resource. 446 ''' 447 self.port = port if port is not None else 0 448 ''' 449 450 ''' 451 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 452 ''' 453 ID of the secret store containing credentials for this resource, if any. 454 ''' 455 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 456 ''' 457 Tags is a map of key, value pairs. 458 ''' 459 self.token = token if token is not None else '' 460 ''' 461 462 '''
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthcheck_namespace
The path used to check the health of your connection. Defaults to default.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
port
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
token
View Source
478 def to_dict(self): 479 return { 480 'egress_filter': self.egress_filter, 481 'healthcheck_namespace': self.healthcheck_namespace, 482 'healthy': self.healthy, 483 'hostname': self.hostname, 484 'id': self.id, 485 'name': self.name, 486 'port': self.port, 487 'secret_store_id': self.secret_store_id, 488 'tags': self.tags, 489 'token': self.token, 490 }
View Source
492 @classmethod 493 def from_dict(cls, d): 494 return cls( 495 egress_filter=d.get('egress_filter'), 496 healthcheck_namespace=d.get('healthcheck_namespace'), 497 healthy=d.get('healthy'), 498 hostname=d.get('hostname'), 499 id=d.get('id'), 500 name=d.get('name'), 501 port=d.get('port'), 502 secret_store_id=d.get('secret_store_id'), 503 tags=d.get('tags'), 504 token=d.get('token'), 505 )
View Source
508class AKSUserImpersonation: 509 ''' 510 511 ''' 512 __slots__ = [ 513 'certificate_authority', 514 'client_certificate', 515 'client_key', 516 'egress_filter', 517 'healthcheck_namespace', 518 'healthy', 519 'hostname', 520 'id', 521 'name', 522 'port', 523 'secret_store_id', 524 'tags', 525 ] 526 527 def __init__( 528 self, 529 certificate_authority=None, 530 client_certificate=None, 531 client_key=None, 532 egress_filter=None, 533 healthcheck_namespace=None, 534 healthy=None, 535 hostname=None, 536 id=None, 537 name=None, 538 port=None, 539 secret_store_id=None, 540 tags=None, 541 ): 542 self.certificate_authority = certificate_authority if certificate_authority is not None else '' 543 ''' 544 545 ''' 546 self.client_certificate = client_certificate if client_certificate is not None else '' 547 ''' 548 549 ''' 550 self.client_key = client_key if client_key is not None else '' 551 ''' 552 553 ''' 554 self.egress_filter = egress_filter if egress_filter is not None else '' 555 ''' 556 A filter applied to the routing logic to pin datasource to nodes. 557 ''' 558 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 559 ''' 560 The path used to check the health of your connection. Defaults to `default`. 561 ''' 562 self.healthy = healthy if healthy is not None else False 563 ''' 564 True if the datasource is reachable and the credentials are valid. 565 ''' 566 self.hostname = hostname if hostname is not None else '' 567 ''' 568 569 ''' 570 self.id = id if id is not None else '' 571 ''' 572 Unique identifier of the Resource. 573 ''' 574 self.name = name if name is not None else '' 575 ''' 576 Unique human-readable name of the Resource. 577 ''' 578 self.port = port if port is not None else 0 579 ''' 580 581 ''' 582 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 583 ''' 584 ID of the secret store containing credentials for this resource, if any. 585 ''' 586 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 587 ''' 588 Tags is a map of key, value pairs. 589 ''' 590 591 def __repr__(self): 592 return '<sdm.AKSUserImpersonation ' + \ 593 'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\ 594 'client_certificate: ' + repr(self.client_certificate) + ' ' +\ 595 'client_key: ' + repr(self.client_key) + ' ' +\ 596 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 597 'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\ 598 'healthy: ' + repr(self.healthy) + ' ' +\ 599 'hostname: ' + repr(self.hostname) + ' ' +\ 600 'id: ' + repr(self.id) + ' ' +\ 601 'name: ' + repr(self.name) + ' ' +\ 602 'port: ' + repr(self.port) + ' ' +\ 603 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 604 'tags: ' + repr(self.tags) + ' ' +\ 605 '>' 606 607 def to_dict(self): 608 return { 609 'certificate_authority': self.certificate_authority, 610 'client_certificate': self.client_certificate, 611 'client_key': self.client_key, 612 'egress_filter': self.egress_filter, 613 'healthcheck_namespace': self.healthcheck_namespace, 614 'healthy': self.healthy, 615 'hostname': self.hostname, 616 'id': self.id, 617 'name': self.name, 618 'port': self.port, 619 'secret_store_id': self.secret_store_id, 620 'tags': self.tags, 621 } 622 623 @classmethod 624 def from_dict(cls, d): 625 return cls( 626 certificate_authority=d.get('certificate_authority'), 627 client_certificate=d.get('client_certificate'), 628 client_key=d.get('client_key'), 629 egress_filter=d.get('egress_filter'), 630 healthcheck_namespace=d.get('healthcheck_namespace'), 631 healthy=d.get('healthy'), 632 hostname=d.get('hostname'), 633 id=d.get('id'), 634 name=d.get('name'), 635 port=d.get('port'), 636 secret_store_id=d.get('secret_store_id'), 637 tags=d.get('tags'), 638 )
#
AKSUserImpersonation(
certificate_authority=None,
client_certificate=None,
client_key=None,
egress_filter=None,
healthcheck_namespace=None,
healthy=None,
hostname=None,
id=None,
name=None,
port=None,
secret_store_id=None,
tags=None
)
View Source
527 def __init__( 528 self, 529 certificate_authority=None, 530 client_certificate=None, 531 client_key=None, 532 egress_filter=None, 533 healthcheck_namespace=None, 534 healthy=None, 535 hostname=None, 536 id=None, 537 name=None, 538 port=None, 539 secret_store_id=None, 540 tags=None, 541 ): 542 self.certificate_authority = certificate_authority if certificate_authority is not None else '' 543 ''' 544 545 ''' 546 self.client_certificate = client_certificate if client_certificate is not None else '' 547 ''' 548 549 ''' 550 self.client_key = client_key if client_key is not None else '' 551 ''' 552 553 ''' 554 self.egress_filter = egress_filter if egress_filter is not None else '' 555 ''' 556 A filter applied to the routing logic to pin datasource to nodes. 557 ''' 558 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 559 ''' 560 The path used to check the health of your connection. Defaults to `default`. 561 ''' 562 self.healthy = healthy if healthy is not None else False 563 ''' 564 True if the datasource is reachable and the credentials are valid. 565 ''' 566 self.hostname = hostname if hostname is not None else '' 567 ''' 568 569 ''' 570 self.id = id if id is not None else '' 571 ''' 572 Unique identifier of the Resource. 573 ''' 574 self.name = name if name is not None else '' 575 ''' 576 Unique human-readable name of the Resource. 577 ''' 578 self.port = port if port is not None else 0 579 ''' 580 581 ''' 582 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 583 ''' 584 ID of the secret store containing credentials for this resource, if any. 585 ''' 586 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 587 ''' 588 Tags is a map of key, value pairs. 589 '''
#
client_certificate
#
client_key
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthcheck_namespace
The path used to check the health of your connection. Defaults to default.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
port
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
View Source
607 def to_dict(self): 608 return { 609 'certificate_authority': self.certificate_authority, 610 'client_certificate': self.client_certificate, 611 'client_key': self.client_key, 612 'egress_filter': self.egress_filter, 613 'healthcheck_namespace': self.healthcheck_namespace, 614 'healthy': self.healthy, 615 'hostname': self.hostname, 616 'id': self.id, 617 'name': self.name, 618 'port': self.port, 619 'secret_store_id': self.secret_store_id, 620 'tags': self.tags, 621 }
View Source
623 @classmethod 624 def from_dict(cls, d): 625 return cls( 626 certificate_authority=d.get('certificate_authority'), 627 client_certificate=d.get('client_certificate'), 628 client_key=d.get('client_key'), 629 egress_filter=d.get('egress_filter'), 630 healthcheck_namespace=d.get('healthcheck_namespace'), 631 healthy=d.get('healthy'), 632 hostname=d.get('hostname'), 633 id=d.get('id'), 634 name=d.get('name'), 635 port=d.get('port'), 636 secret_store_id=d.get('secret_store_id'), 637 tags=d.get('tags'), 638 )
View Source
641class AWS: 642 ''' 643 644 ''' 645 __slots__ = [ 646 'access_key', 647 'egress_filter', 648 'healthcheck_region', 649 'healthy', 650 'id', 651 'name', 652 'role_arn', 653 'role_external_id', 654 'secret_access_key', 655 'secret_store_id', 656 'tags', 657 ] 658 659 def __init__( 660 self, 661 access_key=None, 662 egress_filter=None, 663 healthcheck_region=None, 664 healthy=None, 665 id=None, 666 name=None, 667 role_arn=None, 668 role_external_id=None, 669 secret_access_key=None, 670 secret_store_id=None, 671 tags=None, 672 ): 673 self.access_key = access_key if access_key is not None else '' 674 ''' 675 676 ''' 677 self.egress_filter = egress_filter if egress_filter is not None else '' 678 ''' 679 A filter applied to the routing logic to pin datasource to nodes. 680 ''' 681 self.healthcheck_region = healthcheck_region if healthcheck_region is not None else '' 682 ''' 683 684 ''' 685 self.healthy = healthy if healthy is not None else False 686 ''' 687 True if the datasource is reachable and the credentials are valid. 688 ''' 689 self.id = id if id is not None else '' 690 ''' 691 Unique identifier of the Resource. 692 ''' 693 self.name = name if name is not None else '' 694 ''' 695 Unique human-readable name of the Resource. 696 ''' 697 self.role_arn = role_arn if role_arn is not None else '' 698 ''' 699 700 ''' 701 self.role_external_id = role_external_id if role_external_id is not None else '' 702 ''' 703 704 ''' 705 self.secret_access_key = secret_access_key if secret_access_key is not None else '' 706 ''' 707 708 ''' 709 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 710 ''' 711 ID of the secret store containing credentials for this resource, if any. 712 ''' 713 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 714 ''' 715 Tags is a map of key, value pairs. 716 ''' 717 718 def __repr__(self): 719 return '<sdm.AWS ' + \ 720 'access_key: ' + repr(self.access_key) + ' ' +\ 721 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 722 'healthcheck_region: ' + repr(self.healthcheck_region) + ' ' +\ 723 'healthy: ' + repr(self.healthy) + ' ' +\ 724 'id: ' + repr(self.id) + ' ' +\ 725 'name: ' + repr(self.name) + ' ' +\ 726 'role_arn: ' + repr(self.role_arn) + ' ' +\ 727 'role_external_id: ' + repr(self.role_external_id) + ' ' +\ 728 'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\ 729 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 730 'tags: ' + repr(self.tags) + ' ' +\ 731 '>' 732 733 def to_dict(self): 734 return { 735 'access_key': self.access_key, 736 'egress_filter': self.egress_filter, 737 'healthcheck_region': self.healthcheck_region, 738 'healthy': self.healthy, 739 'id': self.id, 740 'name': self.name, 741 'role_arn': self.role_arn, 742 'role_external_id': self.role_external_id, 743 'secret_access_key': self.secret_access_key, 744 'secret_store_id': self.secret_store_id, 745 'tags': self.tags, 746 } 747 748 @classmethod 749 def from_dict(cls, d): 750 return cls( 751 access_key=d.get('access_key'), 752 egress_filter=d.get('egress_filter'), 753 healthcheck_region=d.get('healthcheck_region'), 754 healthy=d.get('healthy'), 755 id=d.get('id'), 756 name=d.get('name'), 757 role_arn=d.get('role_arn'), 758 role_external_id=d.get('role_external_id'), 759 secret_access_key=d.get('secret_access_key'), 760 secret_store_id=d.get('secret_store_id'), 761 tags=d.get('tags'), 762 )
#
AWS(
access_key=None,
egress_filter=None,
healthcheck_region=None,
healthy=None,
id=None,
name=None,
role_arn=None,
role_external_id=None,
secret_access_key=None,
secret_store_id=None,
tags=None
)
View Source
659 def __init__( 660 self, 661 access_key=None, 662 egress_filter=None, 663 healthcheck_region=None, 664 healthy=None, 665 id=None, 666 name=None, 667 role_arn=None, 668 role_external_id=None, 669 secret_access_key=None, 670 secret_store_id=None, 671 tags=None, 672 ): 673 self.access_key = access_key if access_key is not None else '' 674 ''' 675 676 ''' 677 self.egress_filter = egress_filter if egress_filter is not None else '' 678 ''' 679 A filter applied to the routing logic to pin datasource to nodes. 680 ''' 681 self.healthcheck_region = healthcheck_region if healthcheck_region is not None else '' 682 ''' 683 684 ''' 685 self.healthy = healthy if healthy is not None else False 686 ''' 687 True if the datasource is reachable and the credentials are valid. 688 ''' 689 self.id = id if id is not None else '' 690 ''' 691 Unique identifier of the Resource. 692 ''' 693 self.name = name if name is not None else '' 694 ''' 695 Unique human-readable name of the Resource. 696 ''' 697 self.role_arn = role_arn if role_arn is not None else '' 698 ''' 699 700 ''' 701 self.role_external_id = role_external_id if role_external_id is not None else '' 702 ''' 703 704 ''' 705 self.secret_access_key = secret_access_key if secret_access_key is not None else '' 706 ''' 707 708 ''' 709 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 710 ''' 711 ID of the secret store containing credentials for this resource, if any. 712 ''' 713 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 714 ''' 715 Tags is a map of key, value pairs. 716 '''
#
access_key
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthcheck_region
#
healthy
True if the datasource is reachable and the credentials are valid.
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
role_arn
#
role_external_id
#
secret_access_key
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
View Source
733 def to_dict(self): 734 return { 735 'access_key': self.access_key, 736 'egress_filter': self.egress_filter, 737 'healthcheck_region': self.healthcheck_region, 738 'healthy': self.healthy, 739 'id': self.id, 740 'name': self.name, 741 'role_arn': self.role_arn, 742 'role_external_id': self.role_external_id, 743 'secret_access_key': self.secret_access_key, 744 'secret_store_id': self.secret_store_id, 745 'tags': self.tags, 746 }
View Source
748 @classmethod 749 def from_dict(cls, d): 750 return cls( 751 access_key=d.get('access_key'), 752 egress_filter=d.get('egress_filter'), 753 healthcheck_region=d.get('healthcheck_region'), 754 healthy=d.get('healthy'), 755 id=d.get('id'), 756 name=d.get('name'), 757 role_arn=d.get('role_arn'), 758 role_external_id=d.get('role_external_id'), 759 secret_access_key=d.get('secret_access_key'), 760 secret_store_id=d.get('secret_store_id'), 761 tags=d.get('tags'), 762 )
View Source
765class AWSStore: 766 ''' 767 768 ''' 769 __slots__ = [ 770 'id', 771 'name', 772 'region', 773 'tags', 774 ] 775 776 def __init__( 777 self, 778 id=None, 779 name=None, 780 region=None, 781 tags=None, 782 ): 783 self.id = id if id is not None else '' 784 ''' 785 Unique identifier of the SecretStore. 786 ''' 787 self.name = name if name is not None else '' 788 ''' 789 Unique human-readable name of the SecretStore. 790 ''' 791 self.region = region if region is not None else '' 792 ''' 793 794 ''' 795 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 796 ''' 797 Tags is a map of key, value pairs. 798 ''' 799 800 def __repr__(self): 801 return '<sdm.AWSStore ' + \ 802 'id: ' + repr(self.id) + ' ' +\ 803 'name: ' + repr(self.name) + ' ' +\ 804 'region: ' + repr(self.region) + ' ' +\ 805 'tags: ' + repr(self.tags) + ' ' +\ 806 '>' 807 808 def to_dict(self): 809 return { 810 'id': self.id, 811 'name': self.name, 812 'region': self.region, 813 'tags': self.tags, 814 } 815 816 @classmethod 817 def from_dict(cls, d): 818 return cls( 819 id=d.get('id'), 820 name=d.get('name'), 821 region=d.get('region'), 822 tags=d.get('tags'), 823 )
View Source
776 def __init__( 777 self, 778 id=None, 779 name=None, 780 region=None, 781 tags=None, 782 ): 783 self.id = id if id is not None else '' 784 ''' 785 Unique identifier of the SecretStore. 786 ''' 787 self.name = name if name is not None else '' 788 ''' 789 Unique human-readable name of the SecretStore. 790 ''' 791 self.region = region if region is not None else '' 792 ''' 793 794 ''' 795 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 796 ''' 797 Tags is a map of key, value pairs. 798 '''
#
id
Unique identifier of the SecretStore.
#
name
Unique human-readable name of the SecretStore.
#
region
View Source
826class AccountAttachment: 827 ''' 828 AccountAttachments assign an account to a role. 829 ''' 830 __slots__ = [ 831 'account_id', 832 'id', 833 'role_id', 834 ] 835 836 def __init__( 837 self, 838 account_id=None, 839 id=None, 840 role_id=None, 841 ): 842 self.account_id = account_id if account_id is not None else '' 843 ''' 844 The id of the account of this AccountAttachment. 845 ''' 846 self.id = id if id is not None else '' 847 ''' 848 Unique identifier of the AccountAttachment. 849 ''' 850 self.role_id = role_id if role_id is not None else '' 851 ''' 852 The id of the attached role of this AccountAttachment. 853 ''' 854 855 def __repr__(self): 856 return '<sdm.AccountAttachment ' + \ 857 'account_id: ' + repr(self.account_id) + ' ' +\ 858 'id: ' + repr(self.id) + ' ' +\ 859 'role_id: ' + repr(self.role_id) + ' ' +\ 860 '>' 861 862 def to_dict(self): 863 return { 864 'account_id': self.account_id, 865 'id': self.id, 866 'role_id': self.role_id, 867 } 868 869 @classmethod 870 def from_dict(cls, d): 871 return cls( 872 account_id=d.get('account_id'), 873 id=d.get('id'), 874 role_id=d.get('role_id'), 875 )
AccountAttachments assign an account to a role.
View Source
836 def __init__( 837 self, 838 account_id=None, 839 id=None, 840 role_id=None, 841 ): 842 self.account_id = account_id if account_id is not None else '' 843 ''' 844 The id of the account of this AccountAttachment. 845 ''' 846 self.id = id if id is not None else '' 847 ''' 848 Unique identifier of the AccountAttachment. 849 ''' 850 self.role_id = role_id if role_id is not None else '' 851 ''' 852 The id of the attached role of this AccountAttachment. 853 '''
#
account_id
The id of the account of this AccountAttachment.
#
id
Unique identifier of the AccountAttachment.
#
role_id
The id of the attached role of this AccountAttachment.
View Source
878class AccountAttachmentCreateResponse: 879 ''' 880 AccountAttachmentCreateResponse reports how the AccountAttachments were created in the system. 881 ''' 882 __slots__ = [ 883 'account_attachment', 884 'meta', 885 'rate_limit', 886 ] 887 888 def __init__( 889 self, 890 account_attachment=None, 891 meta=None, 892 rate_limit=None, 893 ): 894 self.account_attachment = account_attachment if account_attachment is not None else None 895 ''' 896 The created AccountAttachment. 897 ''' 898 self.meta = meta if meta is not None else None 899 ''' 900 Reserved for future use. 901 ''' 902 self.rate_limit = rate_limit if rate_limit is not None else None 903 ''' 904 Rate limit information. 905 ''' 906 907 def __repr__(self): 908 return '<sdm.AccountAttachmentCreateResponse ' + \ 909 'account_attachment: ' + repr(self.account_attachment) + ' ' +\ 910 'meta: ' + repr(self.meta) + ' ' +\ 911 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 912 '>' 913 914 def to_dict(self): 915 return { 916 'account_attachment': self.account_attachment, 917 'meta': self.meta, 918 'rate_limit': self.rate_limit, 919 } 920 921 @classmethod 922 def from_dict(cls, d): 923 return cls( 924 account_attachment=d.get('account_attachment'), 925 meta=d.get('meta'), 926 rate_limit=d.get('rate_limit'), 927 )
AccountAttachmentCreateResponse reports how the AccountAttachments were created in the system.
View Source
888 def __init__( 889 self, 890 account_attachment=None, 891 meta=None, 892 rate_limit=None, 893 ): 894 self.account_attachment = account_attachment if account_attachment is not None else None 895 ''' 896 The created AccountAttachment. 897 ''' 898 self.meta = meta if meta is not None else None 899 ''' 900 Reserved for future use. 901 ''' 902 self.rate_limit = rate_limit if rate_limit is not None else None 903 ''' 904 Rate limit information. 905 '''
#
account_attachment
The created AccountAttachment.
#
meta
Reserved for future use.
#
rate_limit
Rate limit information.
View Source
930class AccountAttachmentDeleteResponse: 931 ''' 932 AccountAttachmentDeleteResponse returns information about a AccountAttachment that was deleted. 933 ''' 934 __slots__ = [ 935 'meta', 936 'rate_limit', 937 ] 938 939 def __init__( 940 self, 941 meta=None, 942 rate_limit=None, 943 ): 944 self.meta = meta if meta is not None else None 945 ''' 946 Reserved for future use. 947 ''' 948 self.rate_limit = rate_limit if rate_limit is not None else None 949 ''' 950 Rate limit information. 951 ''' 952 953 def __repr__(self): 954 return '<sdm.AccountAttachmentDeleteResponse ' + \ 955 'meta: ' + repr(self.meta) + ' ' +\ 956 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 957 '>' 958 959 def to_dict(self): 960 return { 961 'meta': self.meta, 962 'rate_limit': self.rate_limit, 963 } 964 965 @classmethod 966 def from_dict(cls, d): 967 return cls( 968 meta=d.get('meta'), 969 rate_limit=d.get('rate_limit'), 970 )
AccountAttachmentDeleteResponse returns information about a AccountAttachment that was deleted.
#
meta
Reserved for future use.
#
rate_limit
Rate limit information.
View Source
973class AccountAttachmentGetResponse: 974 ''' 975 AccountAttachmentGetResponse returns a requested AccountAttachment. 976 ''' 977 __slots__ = [ 978 'account_attachment', 979 'meta', 980 'rate_limit', 981 ] 982 983 def __init__( 984 self, 985 account_attachment=None, 986 meta=None, 987 rate_limit=None, 988 ): 989 self.account_attachment = account_attachment if account_attachment is not None else None 990 ''' 991 The requested AccountAttachment. 992 ''' 993 self.meta = meta if meta is not None else None 994 ''' 995 Reserved for future use. 996 ''' 997 self.rate_limit = rate_limit if rate_limit is not None else None 998 ''' 999 Rate limit information. 1000 ''' 1001 1002 def __repr__(self): 1003 return '<sdm.AccountAttachmentGetResponse ' + \ 1004 'account_attachment: ' + repr(self.account_attachment) + ' ' +\ 1005 'meta: ' + repr(self.meta) + ' ' +\ 1006 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 1007 '>' 1008 1009 def to_dict(self): 1010 return { 1011 'account_attachment': self.account_attachment, 1012 'meta': self.meta, 1013 'rate_limit': self.rate_limit, 1014 } 1015 1016 @classmethod 1017 def from_dict(cls, d): 1018 return cls( 1019 account_attachment=d.get('account_attachment'), 1020 meta=d.get('meta'), 1021 rate_limit=d.get('rate_limit'), 1022 )
AccountAttachmentGetResponse returns a requested AccountAttachment.
View Source
983 def __init__( 984 self, 985 account_attachment=None, 986 meta=None, 987 rate_limit=None, 988 ): 989 self.account_attachment = account_attachment if account_attachment is not None else None 990 ''' 991 The requested AccountAttachment. 992 ''' 993 self.meta = meta if meta is not None else None 994 ''' 995 Reserved for future use. 996 ''' 997 self.rate_limit = rate_limit if rate_limit is not None else None 998 ''' 999 Rate limit information. 1000 '''
#
account_attachment
The requested AccountAttachment.
#
meta
Reserved for future use.
#
rate_limit
Rate limit information.
View Source
1025class AccountCreateResponse: 1026 ''' 1027 AccountCreateResponse reports how the Accounts were created in the system. 1028 ''' 1029 __slots__ = [ 1030 'account', 1031 'meta', 1032 'rate_limit', 1033 'token', 1034 ] 1035 1036 def __init__( 1037 self, 1038 account=None, 1039 meta=None, 1040 rate_limit=None, 1041 token=None, 1042 ): 1043 self.account = account if account is not None else None 1044 ''' 1045 The created Account. 1046 ''' 1047 self.meta = meta if meta is not None else None 1048 ''' 1049 Reserved for future use. 1050 ''' 1051 self.rate_limit = rate_limit if rate_limit is not None else None 1052 ''' 1053 Rate limit information. 1054 ''' 1055 self.token = token if token is not None else '' 1056 ''' 1057 The auth token generated for the Account. The Account will use this token to 1058 authenticate with the strongDM API. 1059 ''' 1060 1061 def __repr__(self): 1062 return '<sdm.AccountCreateResponse ' + \ 1063 'account: ' + repr(self.account) + ' ' +\ 1064 'meta: ' + repr(self.meta) + ' ' +\ 1065 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 1066 'token: ' + repr(self.token) + ' ' +\ 1067 '>' 1068 1069 def to_dict(self): 1070 return { 1071 'account': self.account, 1072 'meta': self.meta, 1073 'rate_limit': self.rate_limit, 1074 'token': self.token, 1075 } 1076 1077 @classmethod 1078 def from_dict(cls, d): 1079 return cls( 1080 account=d.get('account'), 1081 meta=d.get('meta'), 1082 rate_limit=d.get('rate_limit'), 1083 token=d.get('token'), 1084 )
AccountCreateResponse reports how the Accounts were created in the system.
View Source
1036 def __init__( 1037 self, 1038 account=None, 1039 meta=None, 1040 rate_limit=None, 1041 token=None, 1042 ): 1043 self.account = account if account is not None else None 1044 ''' 1045 The created Account. 1046 ''' 1047 self.meta = meta if meta is not None else None 1048 ''' 1049 Reserved for future use. 1050 ''' 1051 self.rate_limit = rate_limit if rate_limit is not None else None 1052 ''' 1053 Rate limit information. 1054 ''' 1055 self.token = token if token is not None else '' 1056 ''' 1057 The auth token generated for the Account. The Account will use this token to 1058 authenticate with the strongDM API. 1059 '''
#
account
The created Account.
#
meta
Reserved for future use.
#
rate_limit
Rate limit information.
#
token
The auth token generated for the Account. The Account will use this token to authenticate with the strongDM API.
View Source
1087class AccountDeleteResponse: 1088 ''' 1089 AccountDeleteResponse returns information about a Account that was deleted. 1090 ''' 1091 __slots__ = [ 1092 'meta', 1093 'rate_limit', 1094 ] 1095 1096 def __init__( 1097 self, 1098 meta=None, 1099 rate_limit=None, 1100 ): 1101 self.meta = meta if meta is not None else None 1102 ''' 1103 Reserved for future use. 1104 ''' 1105 self.rate_limit = rate_limit if rate_limit is not None else None 1106 ''' 1107 Rate limit information. 1108 ''' 1109 1110 def __repr__(self): 1111 return '<sdm.AccountDeleteResponse ' + \ 1112 'meta: ' + repr(self.meta) + ' ' +\ 1113 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 1114 '>' 1115 1116 def to_dict(self): 1117 return { 1118 'meta': self.meta, 1119 'rate_limit': self.rate_limit, 1120 } 1121 1122 @classmethod 1123 def from_dict(cls, d): 1124 return cls( 1125 meta=d.get('meta'), 1126 rate_limit=d.get('rate_limit'), 1127 )
AccountDeleteResponse returns information about a Account that was deleted.
View Source
#
meta
Reserved for future use.
#
rate_limit
Rate limit information.
View Source
1130class AccountGetResponse: 1131 ''' 1132 AccountGetResponse returns a requested Account. 1133 ''' 1134 __slots__ = [ 1135 'account', 1136 'meta', 1137 'rate_limit', 1138 ] 1139 1140 def __init__( 1141 self, 1142 account=None, 1143 meta=None, 1144 rate_limit=None, 1145 ): 1146 self.account = account if account is not None else None 1147 ''' 1148 The requested Account. 1149 ''' 1150 self.meta = meta if meta is not None else None 1151 ''' 1152 Reserved for future use. 1153 ''' 1154 self.rate_limit = rate_limit if rate_limit is not None else None 1155 ''' 1156 Rate limit information. 1157 ''' 1158 1159 def __repr__(self): 1160 return '<sdm.AccountGetResponse ' + \ 1161 'account: ' + repr(self.account) + ' ' +\ 1162 'meta: ' + repr(self.meta) + ' ' +\ 1163 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 1164 '>' 1165 1166 def to_dict(self): 1167 return { 1168 'account': self.account, 1169 'meta': self.meta, 1170 'rate_limit': self.rate_limit, 1171 } 1172 1173 @classmethod 1174 def from_dict(cls, d): 1175 return cls( 1176 account=d.get('account'), 1177 meta=d.get('meta'), 1178 rate_limit=d.get('rate_limit'), 1179 )
AccountGetResponse returns a requested Account.
View Source
1140 def __init__( 1141 self, 1142 account=None, 1143 meta=None, 1144 rate_limit=None, 1145 ): 1146 self.account = account if account is not None else None 1147 ''' 1148 The requested Account. 1149 ''' 1150 self.meta = meta if meta is not None else None 1151 ''' 1152 Reserved for future use. 1153 ''' 1154 self.rate_limit = rate_limit if rate_limit is not None else None 1155 ''' 1156 Rate limit information. 1157 '''
#
account
The requested Account.
#
meta
Reserved for future use.
#
rate_limit
Rate limit information.
View Source
1182class AccountGrant: 1183 ''' 1184 AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource. 1185 ''' 1186 __slots__ = [ 1187 'account_id', 1188 'id', 1189 'resource_id', 1190 'start_from', 1191 'valid_until', 1192 ] 1193 1194 def __init__( 1195 self, 1196 account_id=None, 1197 id=None, 1198 resource_id=None, 1199 start_from=None, 1200 valid_until=None, 1201 ): 1202 self.account_id = account_id if account_id is not None else '' 1203 ''' 1204 The id of the attached role of this AccountGrant. 1205 ''' 1206 self.id = id if id is not None else '' 1207 ''' 1208 Unique identifier of the AccountGrant. 1209 ''' 1210 self.resource_id = resource_id if resource_id is not None else '' 1211 ''' 1212 The id of the composite role of this AccountGrant. 1213 ''' 1214 self.start_from = start_from if start_from is not None else None 1215 ''' 1216 The timestamp when the resource will be granted. Optional. Both start_at 1217 and end_at must be defined together, or not defined at all. 1218 ''' 1219 self.valid_until = valid_until if valid_until is not None else None 1220 ''' 1221 The timestamp when the resource grant will expire. Optional. Both 1222 start_at and end_at must be defined together, or not defined at all. 1223 ''' 1224 1225 def __repr__(self): 1226 return '<sdm.AccountGrant ' + \ 1227 'account_id: ' + repr(self.account_id) + ' ' +\ 1228 'id: ' + repr(self.id) + ' ' +\ 1229 'resource_id: ' + repr(self.resource_id) + ' ' +\ 1230 'start_from: ' + repr(self.start_from) + ' ' +\ 1231 'valid_until: ' + repr(self.valid_until) + ' ' +\ 1232 '>' 1233 1234 def to_dict(self): 1235 return { 1236 'account_id': self.account_id, 1237 'id': self.id, 1238 'resource_id': self.resource_id, 1239 'start_from': self.start_from, 1240 'valid_until': self.valid_until, 1241 } 1242 1243 @classmethod 1244 def from_dict(cls, d): 1245 return cls( 1246 account_id=d.get('account_id'), 1247 id=d.get('id'), 1248 resource_id=d.get('resource_id'), 1249 start_from=d.get('start_from'), 1250 valid_until=d.get('valid_until'), 1251 )
AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource.
View Source
1194 def __init__( 1195 self, 1196 account_id=None, 1197 id=None, 1198 resource_id=None, 1199 start_from=None, 1200 valid_until=None, 1201 ): 1202 self.account_id = account_id if account_id is not None else '' 1203 ''' 1204 The id of the attached role of this AccountGrant. 1205 ''' 1206 self.id = id if id is not None else '' 1207 ''' 1208 Unique identifier of the AccountGrant. 1209 ''' 1210 self.resource_id = resource_id if resource_id is not None else '' 1211 ''' 1212 The id of the composite role of this AccountGrant. 1213 ''' 1214 self.start_from = start_from if start_from is not None else None 1215 ''' 1216 The timestamp when the resource will be granted. Optional. Both start_at 1217 and end_at must be defined together, or not defined at all. 1218 ''' 1219 self.valid_until = valid_until if valid_until is not None else None 1220 ''' 1221 The timestamp when the resource grant will expire. Optional. Both 1222 start_at and end_at must be defined together, or not defined at all. 1223 '''
#
account_id
The id of the attached role of this AccountGrant.
#
id
Unique identifier of the AccountGrant.
#
resource_id
The id of the composite role of this AccountGrant.
#
start_from
The timestamp when the resource will be granted. Optional. Both start_at and end_at must be defined together, or not defined at all.
#
valid_until
The timestamp when the resource grant will expire. Optional. Both start_at and end_at must be defined together, or not defined at all.
View Source
1254class AccountGrantCreateResponse: 1255 ''' 1256 AccountGrantCreateResponse reports how the AccountGrants were created in the system. 1257 ''' 1258 __slots__ = [ 1259 'account_grant', 1260 'meta', 1261 'rate_limit', 1262 ] 1263 1264 def __init__( 1265 self, 1266 account_grant=None, 1267 meta=None, 1268 rate_limit=None, 1269 ): 1270 self.account_grant = account_grant if account_grant is not None else None 1271 ''' 1272 The created AccountGrant. 1273 ''' 1274 self.meta = meta if meta is not None else None 1275 ''' 1276 Reserved for future use. 1277 ''' 1278 self.rate_limit = rate_limit if rate_limit is not None else None 1279 ''' 1280 Rate limit information. 1281 ''' 1282 1283 def __repr__(self): 1284 return '<sdm.AccountGrantCreateResponse ' + \ 1285 'account_grant: ' + repr(self.account_grant) + ' ' +\ 1286 'meta: ' + repr(self.meta) + ' ' +\ 1287 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 1288 '>' 1289 1290 def to_dict(self): 1291 return { 1292 'account_grant': self.account_grant, 1293 'meta': self.meta, 1294 'rate_limit': self.rate_limit, 1295 } 1296 1297 @classmethod 1298 def from_dict(cls, d): 1299 return cls( 1300 account_grant=d.get('account_grant'), 1301 meta=d.get('meta'), 1302 rate_limit=d.get('rate_limit'), 1303 )
AccountGrantCreateResponse reports how the AccountGrants were created in the system.
View Source
1264 def __init__( 1265 self, 1266 account_grant=None, 1267 meta=None, 1268 rate_limit=None, 1269 ): 1270 self.account_grant = account_grant if account_grant is not None else None 1271 ''' 1272 The created AccountGrant. 1273 ''' 1274 self.meta = meta if meta is not None else None 1275 ''' 1276 Reserved for future use. 1277 ''' 1278 self.rate_limit = rate_limit if rate_limit is not None else None 1279 ''' 1280 Rate limit information. 1281 '''
#
account_grant
The created AccountGrant.
#
meta
Reserved for future use.
#
rate_limit
Rate limit information.
View Source
1306class AccountGrantDeleteResponse: 1307 ''' 1308 AccountGrantDeleteResponse returns information about a AccountGrant that was deleted. 1309 ''' 1310 __slots__ = [ 1311 'meta', 1312 'rate_limit', 1313 ] 1314 1315 def __init__( 1316 self, 1317 meta=None, 1318 rate_limit=None, 1319 ): 1320 self.meta = meta if meta is not None else None 1321 ''' 1322 Reserved for future use. 1323 ''' 1324 self.rate_limit = rate_limit if rate_limit is not None else None 1325 ''' 1326 Rate limit information. 1327 ''' 1328 1329 def __repr__(self): 1330 return '<sdm.AccountGrantDeleteResponse ' + \ 1331 'meta: ' + repr(self.meta) + ' ' +\ 1332 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 1333 '>' 1334 1335 def to_dict(self): 1336 return { 1337 'meta': self.meta, 1338 'rate_limit': self.rate_limit, 1339 } 1340 1341 @classmethod 1342 def from_dict(cls, d): 1343 return cls( 1344 meta=d.get('meta'), 1345 rate_limit=d.get('rate_limit'), 1346 )
AccountGrantDeleteResponse returns information about a AccountGrant that was deleted.
View Source
#
meta
Reserved for future use.
#
rate_limit
Rate limit information.
View Source
1349class AccountGrantGetResponse: 1350 ''' 1351 AccountGrantGetResponse returns a requested AccountGrant. 1352 ''' 1353 __slots__ = [ 1354 'account_grant', 1355 'meta', 1356 'rate_limit', 1357 ] 1358 1359 def __init__( 1360 self, 1361 account_grant=None, 1362 meta=None, 1363 rate_limit=None, 1364 ): 1365 self.account_grant = account_grant if account_grant is not None else None 1366 ''' 1367 The requested AccountGrant. 1368 ''' 1369 self.meta = meta if meta is not None else None 1370 ''' 1371 Reserved for future use. 1372 ''' 1373 self.rate_limit = rate_limit if rate_limit is not None else None 1374 ''' 1375 Rate limit information. 1376 ''' 1377 1378 def __repr__(self): 1379 return '<sdm.AccountGrantGetResponse ' + \ 1380 'account_grant: ' + repr(self.account_grant) + ' ' +\ 1381 'meta: ' + repr(self.meta) + ' ' +\ 1382 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 1383 '>' 1384 1385 def to_dict(self): 1386 return { 1387 'account_grant': self.account_grant, 1388 'meta': self.meta, 1389 'rate_limit': self.rate_limit, 1390 } 1391 1392 @classmethod 1393 def from_dict(cls, d): 1394 return cls( 1395 account_grant=d.get('account_grant'), 1396 meta=d.get('meta'), 1397 rate_limit=d.get('rate_limit'), 1398 )
AccountGrantGetResponse returns a requested AccountGrant.
View Source
1359 def __init__( 1360 self, 1361 account_grant=None, 1362 meta=None, 1363 rate_limit=None, 1364 ): 1365 self.account_grant = account_grant if account_grant is not None else None 1366 ''' 1367 The requested AccountGrant. 1368 ''' 1369 self.meta = meta if meta is not None else None 1370 ''' 1371 Reserved for future use. 1372 ''' 1373 self.rate_limit = rate_limit if rate_limit is not None else None 1374 ''' 1375 Rate limit information. 1376 '''
#
account_grant
The requested AccountGrant.
#
meta
Reserved for future use.
#
rate_limit
Rate limit information.
View Source
1401class AccountUpdateResponse: 1402 ''' 1403 AccountUpdateResponse returns the fields of a Account after it has been updated by 1404 a AccountUpdateRequest. 1405 ''' 1406 __slots__ = [ 1407 'account', 1408 'meta', 1409 'rate_limit', 1410 ] 1411 1412 def __init__( 1413 self, 1414 account=None, 1415 meta=None, 1416 rate_limit=None, 1417 ): 1418 self.account = account if account is not None else None 1419 ''' 1420 The updated Account. 1421 ''' 1422 self.meta = meta if meta is not None else None 1423 ''' 1424 Reserved for future use. 1425 ''' 1426 self.rate_limit = rate_limit if rate_limit is not None else None 1427 ''' 1428 Rate limit information. 1429 ''' 1430 1431 def __repr__(self): 1432 return '<sdm.AccountUpdateResponse ' + \ 1433 'account: ' + repr(self.account) + ' ' +\ 1434 'meta: ' + repr(self.meta) + ' ' +\ 1435 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 1436 '>' 1437 1438 def to_dict(self): 1439 return { 1440 'account': self.account, 1441 'meta': self.meta, 1442 'rate_limit': self.rate_limit, 1443 } 1444 1445 @classmethod 1446 def from_dict(cls, d): 1447 return cls( 1448 account=d.get('account'), 1449 meta=d.get('meta'), 1450 rate_limit=d.get('rate_limit'), 1451 )
AccountUpdateResponse returns the fields of a Account after it has been updated by a AccountUpdateRequest.
View Source
1412 def __init__( 1413 self, 1414 account=None, 1415 meta=None, 1416 rate_limit=None, 1417 ): 1418 self.account = account if account is not None else None 1419 ''' 1420 The updated Account. 1421 ''' 1422 self.meta = meta if meta is not None else None 1423 ''' 1424 Reserved for future use. 1425 ''' 1426 self.rate_limit = rate_limit if rate_limit is not None else None 1427 ''' 1428 Rate limit information. 1429 '''
#
account
The updated Account.
#
meta
Reserved for future use.
#
rate_limit
Rate limit information.
View Source
1454class AmazonEKS: 1455 ''' 1456 1457 ''' 1458 __slots__ = [ 1459 'access_key', 1460 'certificate_authority', 1461 'cluster_name', 1462 'egress_filter', 1463 'endpoint', 1464 'healthcheck_namespace', 1465 'healthy', 1466 'id', 1467 'name', 1468 'region', 1469 'role_arn', 1470 'role_external_id', 1471 'secret_access_key', 1472 'secret_store_id', 1473 'tags', 1474 ] 1475 1476 def __init__( 1477 self, 1478 access_key=None, 1479 certificate_authority=None, 1480 cluster_name=None, 1481 egress_filter=None, 1482 endpoint=None, 1483 healthcheck_namespace=None, 1484 healthy=None, 1485 id=None, 1486 name=None, 1487 region=None, 1488 role_arn=None, 1489 role_external_id=None, 1490 secret_access_key=None, 1491 secret_store_id=None, 1492 tags=None, 1493 ): 1494 self.access_key = access_key if access_key is not None else '' 1495 ''' 1496 1497 ''' 1498 self.certificate_authority = certificate_authority if certificate_authority is not None else '' 1499 ''' 1500 1501 ''' 1502 self.cluster_name = cluster_name if cluster_name is not None else '' 1503 ''' 1504 1505 ''' 1506 self.egress_filter = egress_filter if egress_filter is not None else '' 1507 ''' 1508 A filter applied to the routing logic to pin datasource to nodes. 1509 ''' 1510 self.endpoint = endpoint if endpoint is not None else '' 1511 ''' 1512 1513 ''' 1514 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 1515 ''' 1516 The path used to check the health of your connection. Defaults to `default`. 1517 ''' 1518 self.healthy = healthy if healthy is not None else False 1519 ''' 1520 True if the datasource is reachable and the credentials are valid. 1521 ''' 1522 self.id = id if id is not None else '' 1523 ''' 1524 Unique identifier of the Resource. 1525 ''' 1526 self.name = name if name is not None else '' 1527 ''' 1528 Unique human-readable name of the Resource. 1529 ''' 1530 self.region = region if region is not None else '' 1531 ''' 1532 1533 ''' 1534 self.role_arn = role_arn if role_arn is not None else '' 1535 ''' 1536 1537 ''' 1538 self.role_external_id = role_external_id if role_external_id is not None else '' 1539 ''' 1540 1541 ''' 1542 self.secret_access_key = secret_access_key if secret_access_key is not None else '' 1543 ''' 1544 1545 ''' 1546 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 1547 ''' 1548 ID of the secret store containing credentials for this resource, if any. 1549 ''' 1550 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 1551 ''' 1552 Tags is a map of key, value pairs. 1553 ''' 1554 1555 def __repr__(self): 1556 return '<sdm.AmazonEKS ' + \ 1557 'access_key: ' + repr(self.access_key) + ' ' +\ 1558 'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\ 1559 'cluster_name: ' + repr(self.cluster_name) + ' ' +\ 1560 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 1561 'endpoint: ' + repr(self.endpoint) + ' ' +\ 1562 'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\ 1563 'healthy: ' + repr(self.healthy) + ' ' +\ 1564 'id: ' + repr(self.id) + ' ' +\ 1565 'name: ' + repr(self.name) + ' ' +\ 1566 'region: ' + repr(self.region) + ' ' +\ 1567 'role_arn: ' + repr(self.role_arn) + ' ' +\ 1568 'role_external_id: ' + repr(self.role_external_id) + ' ' +\ 1569 'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\ 1570 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 1571 'tags: ' + repr(self.tags) + ' ' +\ 1572 '>' 1573 1574 def to_dict(self): 1575 return { 1576 'access_key': self.access_key, 1577 'certificate_authority': self.certificate_authority, 1578 'cluster_name': self.cluster_name, 1579 'egress_filter': self.egress_filter, 1580 'endpoint': self.endpoint, 1581 'healthcheck_namespace': self.healthcheck_namespace, 1582 'healthy': self.healthy, 1583 'id': self.id, 1584 'name': self.name, 1585 'region': self.region, 1586 'role_arn': self.role_arn, 1587 'role_external_id': self.role_external_id, 1588 'secret_access_key': self.secret_access_key, 1589 'secret_store_id': self.secret_store_id, 1590 'tags': self.tags, 1591 } 1592 1593 @classmethod 1594 def from_dict(cls, d): 1595 return cls( 1596 access_key=d.get('access_key'), 1597 certificate_authority=d.get('certificate_authority'), 1598 cluster_name=d.get('cluster_name'), 1599 egress_filter=d.get('egress_filter'), 1600 endpoint=d.get('endpoint'), 1601 healthcheck_namespace=d.get('healthcheck_namespace'), 1602 healthy=d.get('healthy'), 1603 id=d.get('id'), 1604 name=d.get('name'), 1605 region=d.get('region'), 1606 role_arn=d.get('role_arn'), 1607 role_external_id=d.get('role_external_id'), 1608 secret_access_key=d.get('secret_access_key'), 1609 secret_store_id=d.get('secret_store_id'), 1610 tags=d.get('tags'), 1611 )
#
AmazonEKS(
access_key=None,
certificate_authority=None,
cluster_name=None,
egress_filter=None,
endpoint=None,
healthcheck_namespace=None,
healthy=None,
id=None,
name=None,
region=None,
role_arn=None,
role_external_id=None,
secret_access_key=None,
secret_store_id=None,
tags=None
)
View Source
1476 def __init__( 1477 self, 1478 access_key=None, 1479 certificate_authority=None, 1480 cluster_name=None, 1481 egress_filter=None, 1482 endpoint=None, 1483 healthcheck_namespace=None, 1484 healthy=None, 1485 id=None, 1486 name=None, 1487 region=None, 1488 role_arn=None, 1489 role_external_id=None, 1490 secret_access_key=None, 1491 secret_store_id=None, 1492 tags=None, 1493 ): 1494 self.access_key = access_key if access_key is not None else '' 1495 ''' 1496 1497 ''' 1498 self.certificate_authority = certificate_authority if certificate_authority is not None else '' 1499 ''' 1500 1501 ''' 1502 self.cluster_name = cluster_name if cluster_name is not None else '' 1503 ''' 1504 1505 ''' 1506 self.egress_filter = egress_filter if egress_filter is not None else '' 1507 ''' 1508 A filter applied to the routing logic to pin datasource to nodes. 1509 ''' 1510 self.endpoint = endpoint if endpoint is not None else '' 1511 ''' 1512 1513 ''' 1514 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 1515 ''' 1516 The path used to check the health of your connection. Defaults to `default`. 1517 ''' 1518 self.healthy = healthy if healthy is not None else False 1519 ''' 1520 True if the datasource is reachable and the credentials are valid. 1521 ''' 1522 self.id = id if id is not None else '' 1523 ''' 1524 Unique identifier of the Resource. 1525 ''' 1526 self.name = name if name is not None else '' 1527 ''' 1528 Unique human-readable name of the Resource. 1529 ''' 1530 self.region = region if region is not None else '' 1531 ''' 1532 1533 ''' 1534 self.role_arn = role_arn if role_arn is not None else '' 1535 ''' 1536 1537 ''' 1538 self.role_external_id = role_external_id if role_external_id is not None else '' 1539 ''' 1540 1541 ''' 1542 self.secret_access_key = secret_access_key if secret_access_key is not None else '' 1543 ''' 1544 1545 ''' 1546 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 1547 ''' 1548 ID of the secret store containing credentials for this resource, if any. 1549 ''' 1550 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 1551 ''' 1552 Tags is a map of key, value pairs. 1553 '''
#
access_key
#
cluster_name
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
endpoint
#
healthcheck_namespace
The path used to check the health of your connection. Defaults to default.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
region
#
role_arn
#
role_external_id
#
secret_access_key
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
View Source
1574 def to_dict(self): 1575 return { 1576 'access_key': self.access_key, 1577 'certificate_authority': self.certificate_authority, 1578 'cluster_name': self.cluster_name, 1579 'egress_filter': self.egress_filter, 1580 'endpoint': self.endpoint, 1581 'healthcheck_namespace': self.healthcheck_namespace, 1582 'healthy': self.healthy, 1583 'id': self.id, 1584 'name': self.name, 1585 'region': self.region, 1586 'role_arn': self.role_arn, 1587 'role_external_id': self.role_external_id, 1588 'secret_access_key': self.secret_access_key, 1589 'secret_store_id': self.secret_store_id, 1590 'tags': self.tags, 1591 }
View Source
1593 @classmethod 1594 def from_dict(cls, d): 1595 return cls( 1596 access_key=d.get('access_key'), 1597 certificate_authority=d.get('certificate_authority'), 1598 cluster_name=d.get('cluster_name'), 1599 egress_filter=d.get('egress_filter'), 1600 endpoint=d.get('endpoint'), 1601 healthcheck_namespace=d.get('healthcheck_namespace'), 1602 healthy=d.get('healthy'), 1603 id=d.get('id'), 1604 name=d.get('name'), 1605 region=d.get('region'), 1606 role_arn=d.get('role_arn'), 1607 role_external_id=d.get('role_external_id'), 1608 secret_access_key=d.get('secret_access_key'), 1609 secret_store_id=d.get('secret_store_id'), 1610 tags=d.get('tags'), 1611 )
View Source
1614class AmazonEKSUserImpersonation: 1615 ''' 1616 1617 ''' 1618 __slots__ = [ 1619 'access_key', 1620 'certificate_authority', 1621 'cluster_name', 1622 'egress_filter', 1623 'endpoint', 1624 'healthcheck_namespace', 1625 'healthy', 1626 'id', 1627 'name', 1628 'region', 1629 'role_arn', 1630 'role_external_id', 1631 'secret_access_key', 1632 'secret_store_id', 1633 'tags', 1634 ] 1635 1636 def __init__( 1637 self, 1638 access_key=None, 1639 certificate_authority=None, 1640 cluster_name=None, 1641 egress_filter=None, 1642 endpoint=None, 1643 healthcheck_namespace=None, 1644 healthy=None, 1645 id=None, 1646 name=None, 1647 region=None, 1648 role_arn=None, 1649 role_external_id=None, 1650 secret_access_key=None, 1651 secret_store_id=None, 1652 tags=None, 1653 ): 1654 self.access_key = access_key if access_key is not None else '' 1655 ''' 1656 1657 ''' 1658 self.certificate_authority = certificate_authority if certificate_authority is not None else '' 1659 ''' 1660 1661 ''' 1662 self.cluster_name = cluster_name if cluster_name is not None else '' 1663 ''' 1664 1665 ''' 1666 self.egress_filter = egress_filter if egress_filter is not None else '' 1667 ''' 1668 A filter applied to the routing logic to pin datasource to nodes. 1669 ''' 1670 self.endpoint = endpoint if endpoint is not None else '' 1671 ''' 1672 1673 ''' 1674 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 1675 ''' 1676 The path used to check the health of your connection. Defaults to `default`. 1677 ''' 1678 self.healthy = healthy if healthy is not None else False 1679 ''' 1680 True if the datasource is reachable and the credentials are valid. 1681 ''' 1682 self.id = id if id is not None else '' 1683 ''' 1684 Unique identifier of the Resource. 1685 ''' 1686 self.name = name if name is not None else '' 1687 ''' 1688 Unique human-readable name of the Resource. 1689 ''' 1690 self.region = region if region is not None else '' 1691 ''' 1692 1693 ''' 1694 self.role_arn = role_arn if role_arn is not None else '' 1695 ''' 1696 1697 ''' 1698 self.role_external_id = role_external_id if role_external_id is not None else '' 1699 ''' 1700 1701 ''' 1702 self.secret_access_key = secret_access_key if secret_access_key is not None else '' 1703 ''' 1704 1705 ''' 1706 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 1707 ''' 1708 ID of the secret store containing credentials for this resource, if any. 1709 ''' 1710 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 1711 ''' 1712 Tags is a map of key, value pairs. 1713 ''' 1714 1715 def __repr__(self): 1716 return '<sdm.AmazonEKSUserImpersonation ' + \ 1717 'access_key: ' + repr(self.access_key) + ' ' +\ 1718 'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\ 1719 'cluster_name: ' + repr(self.cluster_name) + ' ' +\ 1720 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 1721 'endpoint: ' + repr(self.endpoint) + ' ' +\ 1722 'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\ 1723 'healthy: ' + repr(self.healthy) + ' ' +\ 1724 'id: ' + repr(self.id) + ' ' +\ 1725 'name: ' + repr(self.name) + ' ' +\ 1726 'region: ' + repr(self.region) + ' ' +\ 1727 'role_arn: ' + repr(self.role_arn) + ' ' +\ 1728 'role_external_id: ' + repr(self.role_external_id) + ' ' +\ 1729 'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\ 1730 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 1731 'tags: ' + repr(self.tags) + ' ' +\ 1732 '>' 1733 1734 def to_dict(self): 1735 return { 1736 'access_key': self.access_key, 1737 'certificate_authority': self.certificate_authority, 1738 'cluster_name': self.cluster_name, 1739 'egress_filter': self.egress_filter, 1740 'endpoint': self.endpoint, 1741 'healthcheck_namespace': self.healthcheck_namespace, 1742 'healthy': self.healthy, 1743 'id': self.id, 1744 'name': self.name, 1745 'region': self.region, 1746 'role_arn': self.role_arn, 1747 'role_external_id': self.role_external_id, 1748 'secret_access_key': self.secret_access_key, 1749 'secret_store_id': self.secret_store_id, 1750 'tags': self.tags, 1751 } 1752 1753 @classmethod 1754 def from_dict(cls, d): 1755 return cls( 1756 access_key=d.get('access_key'), 1757 certificate_authority=d.get('certificate_authority'), 1758 cluster_name=d.get('cluster_name'), 1759 egress_filter=d.get('egress_filter'), 1760 endpoint=d.get('endpoint'), 1761 healthcheck_namespace=d.get('healthcheck_namespace'), 1762 healthy=d.get('healthy'), 1763 id=d.get('id'), 1764 name=d.get('name'), 1765 region=d.get('region'), 1766 role_arn=d.get('role_arn'), 1767 role_external_id=d.get('role_external_id'), 1768 secret_access_key=d.get('secret_access_key'), 1769 secret_store_id=d.get('secret_store_id'), 1770 tags=d.get('tags'), 1771 )
#
AmazonEKSUserImpersonation(
access_key=None,
certificate_authority=None,
cluster_name=None,
egress_filter=None,
endpoint=None,
healthcheck_namespace=None,
healthy=None,
id=None,
name=None,
region=None,
role_arn=None,
role_external_id=None,
secret_access_key=None,
secret_store_id=None,
tags=None
)
View Source
1636 def __init__( 1637 self, 1638 access_key=None, 1639 certificate_authority=None, 1640 cluster_name=None, 1641 egress_filter=None, 1642 endpoint=None, 1643 healthcheck_namespace=None, 1644 healthy=None, 1645 id=None, 1646 name=None, 1647 region=None, 1648 role_arn=None, 1649 role_external_id=None, 1650 secret_access_key=None, 1651 secret_store_id=None, 1652 tags=None, 1653 ): 1654 self.access_key = access_key if access_key is not None else '' 1655 ''' 1656 1657 ''' 1658 self.certificate_authority = certificate_authority if certificate_authority is not None else '' 1659 ''' 1660 1661 ''' 1662 self.cluster_name = cluster_name if cluster_name is not None else '' 1663 ''' 1664 1665 ''' 1666 self.egress_filter = egress_filter if egress_filter is not None else '' 1667 ''' 1668 A filter applied to the routing logic to pin datasource to nodes. 1669 ''' 1670 self.endpoint = endpoint if endpoint is not None else '' 1671 ''' 1672 1673 ''' 1674 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 1675 ''' 1676 The path used to check the health of your connection. Defaults to `default`. 1677 ''' 1678 self.healthy = healthy if healthy is not None else False 1679 ''' 1680 True if the datasource is reachable and the credentials are valid. 1681 ''' 1682 self.id = id if id is not None else '' 1683 ''' 1684 Unique identifier of the Resource. 1685 ''' 1686 self.name = name if name is not None else '' 1687 ''' 1688 Unique human-readable name of the Resource. 1689 ''' 1690 self.region = region if region is not None else '' 1691 ''' 1692 1693 ''' 1694 self.role_arn = role_arn if role_arn is not None else '' 1695 ''' 1696 1697 ''' 1698 self.role_external_id = role_external_id if role_external_id is not None else '' 1699 ''' 1700 1701 ''' 1702 self.secret_access_key = secret_access_key if secret_access_key is not None else '' 1703 ''' 1704 1705 ''' 1706 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 1707 ''' 1708 ID of the secret store containing credentials for this resource, if any. 1709 ''' 1710 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 1711 ''' 1712 Tags is a map of key, value pairs. 1713 '''
#
access_key
#
cluster_name
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
endpoint
#
healthcheck_namespace
The path used to check the health of your connection. Defaults to default.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
region
#
role_arn
#
role_external_id
#
secret_access_key
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
View Source
1734 def to_dict(self): 1735 return { 1736 'access_key': self.access_key, 1737 'certificate_authority': self.certificate_authority, 1738 'cluster_name': self.cluster_name, 1739 'egress_filter': self.egress_filter, 1740 'endpoint': self.endpoint, 1741 'healthcheck_namespace': self.healthcheck_namespace, 1742 'healthy': self.healthy, 1743 'id': self.id, 1744 'name': self.name, 1745 'region': self.region, 1746 'role_arn': self.role_arn, 1747 'role_external_id': self.role_external_id, 1748 'secret_access_key': self.secret_access_key, 1749 'secret_store_id': self.secret_store_id, 1750 'tags': self.tags, 1751 }
View Source
1753 @classmethod 1754 def from_dict(cls, d): 1755 return cls( 1756 access_key=d.get('access_key'), 1757 certificate_authority=d.get('certificate_authority'), 1758 cluster_name=d.get('cluster_name'), 1759 egress_filter=d.get('egress_filter'), 1760 endpoint=d.get('endpoint'), 1761 healthcheck_namespace=d.get('healthcheck_namespace'), 1762 healthy=d.get('healthy'), 1763 id=d.get('id'), 1764 name=d.get('name'), 1765 region=d.get('region'), 1766 role_arn=d.get('role_arn'), 1767 role_external_id=d.get('role_external_id'), 1768 secret_access_key=d.get('secret_access_key'), 1769 secret_store_id=d.get('secret_store_id'), 1770 tags=d.get('tags'), 1771 )
View Source
1774class AmazonES: 1775 ''' 1776 1777 ''' 1778 __slots__ = [ 1779 'access_key', 1780 'egress_filter', 1781 'endpoint', 1782 'healthy', 1783 'id', 1784 'name', 1785 'port_override', 1786 'region', 1787 'role_arn', 1788 'role_external_id', 1789 'secret_access_key', 1790 'secret_store_id', 1791 'tags', 1792 ] 1793 1794 def __init__( 1795 self, 1796 access_key=None, 1797 egress_filter=None, 1798 endpoint=None, 1799 healthy=None, 1800 id=None, 1801 name=None, 1802 port_override=None, 1803 region=None, 1804 role_arn=None, 1805 role_external_id=None, 1806 secret_access_key=None, 1807 secret_store_id=None, 1808 tags=None, 1809 ): 1810 self.access_key = access_key if access_key is not None else '' 1811 ''' 1812 1813 ''' 1814 self.egress_filter = egress_filter if egress_filter is not None else '' 1815 ''' 1816 A filter applied to the routing logic to pin datasource to nodes. 1817 ''' 1818 self.endpoint = endpoint if endpoint is not None else '' 1819 ''' 1820 1821 ''' 1822 self.healthy = healthy if healthy is not None else False 1823 ''' 1824 True if the datasource is reachable and the credentials are valid. 1825 ''' 1826 self.id = id if id is not None else '' 1827 ''' 1828 Unique identifier of the Resource. 1829 ''' 1830 self.name = name if name is not None else '' 1831 ''' 1832 Unique human-readable name of the Resource. 1833 ''' 1834 self.port_override = port_override if port_override is not None else 0 1835 ''' 1836 1837 ''' 1838 self.region = region if region is not None else '' 1839 ''' 1840 1841 ''' 1842 self.role_arn = role_arn if role_arn is not None else '' 1843 ''' 1844 1845 ''' 1846 self.role_external_id = role_external_id if role_external_id is not None else '' 1847 ''' 1848 1849 ''' 1850 self.secret_access_key = secret_access_key if secret_access_key is not None else '' 1851 ''' 1852 1853 ''' 1854 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 1855 ''' 1856 ID of the secret store containing credentials for this resource, if any. 1857 ''' 1858 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 1859 ''' 1860 Tags is a map of key, value pairs. 1861 ''' 1862 1863 def __repr__(self): 1864 return '<sdm.AmazonES ' + \ 1865 'access_key: ' + repr(self.access_key) + ' ' +\ 1866 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 1867 'endpoint: ' + repr(self.endpoint) + ' ' +\ 1868 'healthy: ' + repr(self.healthy) + ' ' +\ 1869 'id: ' + repr(self.id) + ' ' +\ 1870 'name: ' + repr(self.name) + ' ' +\ 1871 'port_override: ' + repr(self.port_override) + ' ' +\ 1872 'region: ' + repr(self.region) + ' ' +\ 1873 'role_arn: ' + repr(self.role_arn) + ' ' +\ 1874 'role_external_id: ' + repr(self.role_external_id) + ' ' +\ 1875 'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\ 1876 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 1877 'tags: ' + repr(self.tags) + ' ' +\ 1878 '>' 1879 1880 def to_dict(self): 1881 return { 1882 'access_key': self.access_key, 1883 'egress_filter': self.egress_filter, 1884 'endpoint': self.endpoint, 1885 'healthy': self.healthy, 1886 'id': self.id, 1887 'name': self.name, 1888 'port_override': self.port_override, 1889 'region': self.region, 1890 'role_arn': self.role_arn, 1891 'role_external_id': self.role_external_id, 1892 'secret_access_key': self.secret_access_key, 1893 'secret_store_id': self.secret_store_id, 1894 'tags': self.tags, 1895 } 1896 1897 @classmethod 1898 def from_dict(cls, d): 1899 return cls( 1900 access_key=d.get('access_key'), 1901 egress_filter=d.get('egress_filter'), 1902 endpoint=d.get('endpoint'), 1903 healthy=d.get('healthy'), 1904 id=d.get('id'), 1905 name=d.get('name'), 1906 port_override=d.get('port_override'), 1907 region=d.get('region'), 1908 role_arn=d.get('role_arn'), 1909 role_external_id=d.get('role_external_id'), 1910 secret_access_key=d.get('secret_access_key'), 1911 secret_store_id=d.get('secret_store_id'), 1912 tags=d.get('tags'), 1913 )
#
AmazonES(
access_key=None,
egress_filter=None,
endpoint=None,
healthy=None,
id=None,
name=None,
port_override=None,
region=None,
role_arn=None,
role_external_id=None,
secret_access_key=None,
secret_store_id=None,
tags=None
)
View Source
1794 def __init__( 1795 self, 1796 access_key=None, 1797 egress_filter=None, 1798 endpoint=None, 1799 healthy=None, 1800 id=None, 1801 name=None, 1802 port_override=None, 1803 region=None, 1804 role_arn=None, 1805 role_external_id=None, 1806 secret_access_key=None, 1807 secret_store_id=None, 1808 tags=None, 1809 ): 1810 self.access_key = access_key if access_key is not None else '' 1811 ''' 1812 1813 ''' 1814 self.egress_filter = egress_filter if egress_filter is not None else '' 1815 ''' 1816 A filter applied to the routing logic to pin datasource to nodes. 1817 ''' 1818 self.endpoint = endpoint if endpoint is not None else '' 1819 ''' 1820 1821 ''' 1822 self.healthy = healthy if healthy is not None else False 1823 ''' 1824 True if the datasource is reachable and the credentials are valid. 1825 ''' 1826 self.id = id if id is not None else '' 1827 ''' 1828 Unique identifier of the Resource. 1829 ''' 1830 self.name = name if name is not None else '' 1831 ''' 1832 Unique human-readable name of the Resource. 1833 ''' 1834 self.port_override = port_override if port_override is not None else 0 1835 ''' 1836 1837 ''' 1838 self.region = region if region is not None else '' 1839 ''' 1840 1841 ''' 1842 self.role_arn = role_arn if role_arn is not None else '' 1843 ''' 1844 1845 ''' 1846 self.role_external_id = role_external_id if role_external_id is not None else '' 1847 ''' 1848 1849 ''' 1850 self.secret_access_key = secret_access_key if secret_access_key is not None else '' 1851 ''' 1852 1853 ''' 1854 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 1855 ''' 1856 ID of the secret store containing credentials for this resource, if any. 1857 ''' 1858 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 1859 ''' 1860 Tags is a map of key, value pairs. 1861 '''
#
access_key
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
endpoint
#
healthy
True if the datasource is reachable and the credentials are valid.
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
port_override
#
region
#
role_arn
#
role_external_id
#
secret_access_key
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
View Source
1880 def to_dict(self): 1881 return { 1882 'access_key': self.access_key, 1883 'egress_filter': self.egress_filter, 1884 'endpoint': self.endpoint, 1885 'healthy': self.healthy, 1886 'id': self.id, 1887 'name': self.name, 1888 'port_override': self.port_override, 1889 'region': self.region, 1890 'role_arn': self.role_arn, 1891 'role_external_id': self.role_external_id, 1892 'secret_access_key': self.secret_access_key, 1893 'secret_store_id': self.secret_store_id, 1894 'tags': self.tags, 1895 }
View Source
1897 @classmethod 1898 def from_dict(cls, d): 1899 return cls( 1900 access_key=d.get('access_key'), 1901 egress_filter=d.get('egress_filter'), 1902 endpoint=d.get('endpoint'), 1903 healthy=d.get('healthy'), 1904 id=d.get('id'), 1905 name=d.get('name'), 1906 port_override=d.get('port_override'), 1907 region=d.get('region'), 1908 role_arn=d.get('role_arn'), 1909 role_external_id=d.get('role_external_id'), 1910 secret_access_key=d.get('secret_access_key'), 1911 secret_store_id=d.get('secret_store_id'), 1912 tags=d.get('tags'), 1913 )
View Source
1916class AmazonMQAMQP091: 1917 ''' 1918 1919 ''' 1920 __slots__ = [ 1921 'egress_filter', 1922 'healthy', 1923 'hostname', 1924 'id', 1925 'name', 1926 'password', 1927 'port', 1928 'port_override', 1929 'secret_store_id', 1930 'tags', 1931 'tls_required', 1932 'username', 1933 ] 1934 1935 def __init__( 1936 self, 1937 egress_filter=None, 1938 healthy=None, 1939 hostname=None, 1940 id=None, 1941 name=None, 1942 password=None, 1943 port=None, 1944 port_override=None, 1945 secret_store_id=None, 1946 tags=None, 1947 tls_required=None, 1948 username=None, 1949 ): 1950 self.egress_filter = egress_filter if egress_filter is not None else '' 1951 ''' 1952 A filter applied to the routing logic to pin datasource to nodes. 1953 ''' 1954 self.healthy = healthy if healthy is not None else False 1955 ''' 1956 True if the datasource is reachable and the credentials are valid. 1957 ''' 1958 self.hostname = hostname if hostname is not None else '' 1959 ''' 1960 1961 ''' 1962 self.id = id if id is not None else '' 1963 ''' 1964 Unique identifier of the Resource. 1965 ''' 1966 self.name = name if name is not None else '' 1967 ''' 1968 Unique human-readable name of the Resource. 1969 ''' 1970 self.password = password if password is not None else '' 1971 ''' 1972 1973 ''' 1974 self.port = port if port is not None else 0 1975 ''' 1976 1977 ''' 1978 self.port_override = port_override if port_override is not None else 0 1979 ''' 1980 1981 ''' 1982 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 1983 ''' 1984 ID of the secret store containing credentials for this resource, if any. 1985 ''' 1986 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 1987 ''' 1988 Tags is a map of key, value pairs. 1989 ''' 1990 self.tls_required = tls_required if tls_required is not None else False 1991 ''' 1992 1993 ''' 1994 self.username = username if username is not None else '' 1995 ''' 1996 1997 ''' 1998 1999 def __repr__(self): 2000 return '<sdm.AmazonMQAMQP091 ' + \ 2001 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 2002 'healthy: ' + repr(self.healthy) + ' ' +\ 2003 'hostname: ' + repr(self.hostname) + ' ' +\ 2004 'id: ' + repr(self.id) + ' ' +\ 2005 'name: ' + repr(self.name) + ' ' +\ 2006 'password: ' + repr(self.password) + ' ' +\ 2007 'port: ' + repr(self.port) + ' ' +\ 2008 'port_override: ' + repr(self.port_override) + ' ' +\ 2009 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 2010 'tags: ' + repr(self.tags) + ' ' +\ 2011 'tls_required: ' + repr(self.tls_required) + ' ' +\ 2012 'username: ' + repr(self.username) + ' ' +\ 2013 '>' 2014 2015 def to_dict(self): 2016 return { 2017 'egress_filter': self.egress_filter, 2018 'healthy': self.healthy, 2019 'hostname': self.hostname, 2020 'id': self.id, 2021 'name': self.name, 2022 'password': self.password, 2023 'port': self.port, 2024 'port_override': self.port_override, 2025 'secret_store_id': self.secret_store_id, 2026 'tags': self.tags, 2027 'tls_required': self.tls_required, 2028 'username': self.username, 2029 } 2030 2031 @classmethod 2032 def from_dict(cls, d): 2033 return cls( 2034 egress_filter=d.get('egress_filter'), 2035 healthy=d.get('healthy'), 2036 hostname=d.get('hostname'), 2037 id=d.get('id'), 2038 name=d.get('name'), 2039 password=d.get('password'), 2040 port=d.get('port'), 2041 port_override=d.get('port_override'), 2042 secret_store_id=d.get('secret_store_id'), 2043 tags=d.get('tags'), 2044 tls_required=d.get('tls_required'), 2045 username=d.get('username'), 2046 )
#
AmazonMQAMQP091(
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
password=None,
port=None,
port_override=None,
secret_store_id=None,
tags=None,
tls_required=None,
username=None
)
View Source
1935 def __init__( 1936 self, 1937 egress_filter=None, 1938 healthy=None, 1939 hostname=None, 1940 id=None, 1941 name=None, 1942 password=None, 1943 port=None, 1944 port_override=None, 1945 secret_store_id=None, 1946 tags=None, 1947 tls_required=None, 1948 username=None, 1949 ): 1950 self.egress_filter = egress_filter if egress_filter is not None else '' 1951 ''' 1952 A filter applied to the routing logic to pin datasource to nodes. 1953 ''' 1954 self.healthy = healthy if healthy is not None else False 1955 ''' 1956 True if the datasource is reachable and the credentials are valid. 1957 ''' 1958 self.hostname = hostname if hostname is not None else '' 1959 ''' 1960 1961 ''' 1962 self.id = id if id is not None else '' 1963 ''' 1964 Unique identifier of the Resource. 1965 ''' 1966 self.name = name if name is not None else '' 1967 ''' 1968 Unique human-readable name of the Resource. 1969 ''' 1970 self.password = password if password is not None else '' 1971 ''' 1972 1973 ''' 1974 self.port = port if port is not None else 0 1975 ''' 1976 1977 ''' 1978 self.port_override = port_override if port_override is not None else 0 1979 ''' 1980 1981 ''' 1982 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 1983 ''' 1984 ID of the secret store containing credentials for this resource, if any. 1985 ''' 1986 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 1987 ''' 1988 Tags is a map of key, value pairs. 1989 ''' 1990 self.tls_required = tls_required if tls_required is not None else False 1991 ''' 1992 1993 ''' 1994 self.username = username if username is not None else '' 1995 ''' 1996 1997 '''
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
password
#
port
#
port_override
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
tls_required
#
username
View Source
2015 def to_dict(self): 2016 return { 2017 'egress_filter': self.egress_filter, 2018 'healthy': self.healthy, 2019 'hostname': self.hostname, 2020 'id': self.id, 2021 'name': self.name, 2022 'password': self.password, 2023 'port': self.port, 2024 'port_override': self.port_override, 2025 'secret_store_id': self.secret_store_id, 2026 'tags': self.tags, 2027 'tls_required': self.tls_required, 2028 'username': self.username, 2029 }
View Source
2031 @classmethod 2032 def from_dict(cls, d): 2033 return cls( 2034 egress_filter=d.get('egress_filter'), 2035 healthy=d.get('healthy'), 2036 hostname=d.get('hostname'), 2037 id=d.get('id'), 2038 name=d.get('name'), 2039 password=d.get('password'), 2040 port=d.get('port'), 2041 port_override=d.get('port_override'), 2042 secret_store_id=d.get('secret_store_id'), 2043 tags=d.get('tags'), 2044 tls_required=d.get('tls_required'), 2045 username=d.get('username'), 2046 )
View Source
2049class Athena: 2050 ''' 2051 2052 ''' 2053 __slots__ = [ 2054 'access_key', 2055 'egress_filter', 2056 'healthy', 2057 'id', 2058 'name', 2059 'output', 2060 'port_override', 2061 'region', 2062 'role_arn', 2063 'role_external_id', 2064 'secret_access_key', 2065 'secret_store_id', 2066 'tags', 2067 ] 2068 2069 def __init__( 2070 self, 2071 access_key=None, 2072 egress_filter=None, 2073 healthy=None, 2074 id=None, 2075 name=None, 2076 output=None, 2077 port_override=None, 2078 region=None, 2079 role_arn=None, 2080 role_external_id=None, 2081 secret_access_key=None, 2082 secret_store_id=None, 2083 tags=None, 2084 ): 2085 self.access_key = access_key if access_key is not None else '' 2086 ''' 2087 2088 ''' 2089 self.egress_filter = egress_filter if egress_filter is not None else '' 2090 ''' 2091 A filter applied to the routing logic to pin datasource to nodes. 2092 ''' 2093 self.healthy = healthy if healthy is not None else False 2094 ''' 2095 True if the datasource is reachable and the credentials are valid. 2096 ''' 2097 self.id = id if id is not None else '' 2098 ''' 2099 Unique identifier of the Resource. 2100 ''' 2101 self.name = name if name is not None else '' 2102 ''' 2103 Unique human-readable name of the Resource. 2104 ''' 2105 self.output = output if output is not None else '' 2106 ''' 2107 2108 ''' 2109 self.port_override = port_override if port_override is not None else 0 2110 ''' 2111 2112 ''' 2113 self.region = region if region is not None else '' 2114 ''' 2115 2116 ''' 2117 self.role_arn = role_arn if role_arn is not None else '' 2118 ''' 2119 2120 ''' 2121 self.role_external_id = role_external_id if role_external_id is not None else '' 2122 ''' 2123 2124 ''' 2125 self.secret_access_key = secret_access_key if secret_access_key is not None else '' 2126 ''' 2127 2128 ''' 2129 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 2130 ''' 2131 ID of the secret store containing credentials for this resource, if any. 2132 ''' 2133 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 2134 ''' 2135 Tags is a map of key, value pairs. 2136 ''' 2137 2138 def __repr__(self): 2139 return '<sdm.Athena ' + \ 2140 'access_key: ' + repr(self.access_key) + ' ' +\ 2141 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 2142 'healthy: ' + repr(self.healthy) + ' ' +\ 2143 'id: ' + repr(self.id) + ' ' +\ 2144 'name: ' + repr(self.name) + ' ' +\ 2145 'output: ' + repr(self.output) + ' ' +\ 2146 'port_override: ' + repr(self.port_override) + ' ' +\ 2147 'region: ' + repr(self.region) + ' ' +\ 2148 'role_arn: ' + repr(self.role_arn) + ' ' +\ 2149 'role_external_id: ' + repr(self.role_external_id) + ' ' +\ 2150 'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\ 2151 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 2152 'tags: ' + repr(self.tags) + ' ' +\ 2153 '>' 2154 2155 def to_dict(self): 2156 return { 2157 'access_key': self.access_key, 2158 'egress_filter': self.egress_filter, 2159 'healthy': self.healthy, 2160 'id': self.id, 2161 'name': self.name, 2162 'output': self.output, 2163 'port_override': self.port_override, 2164 'region': self.region, 2165 'role_arn': self.role_arn, 2166 'role_external_id': self.role_external_id, 2167 'secret_access_key': self.secret_access_key, 2168 'secret_store_id': self.secret_store_id, 2169 'tags': self.tags, 2170 } 2171 2172 @classmethod 2173 def from_dict(cls, d): 2174 return cls( 2175 access_key=d.get('access_key'), 2176 egress_filter=d.get('egress_filter'), 2177 healthy=d.get('healthy'), 2178 id=d.get('id'), 2179 name=d.get('name'), 2180 output=d.get('output'), 2181 port_override=d.get('port_override'), 2182 region=d.get('region'), 2183 role_arn=d.get('role_arn'), 2184 role_external_id=d.get('role_external_id'), 2185 secret_access_key=d.get('secret_access_key'), 2186 secret_store_id=d.get('secret_store_id'), 2187 tags=d.get('tags'), 2188 )
#
Athena(
access_key=None,
egress_filter=None,
healthy=None,
id=None,
name=None,
output=None,
port_override=None,
region=None,
role_arn=None,
role_external_id=None,
secret_access_key=None,
secret_store_id=None,
tags=None
)
View Source
2069 def __init__( 2070 self, 2071 access_key=None, 2072 egress_filter=None, 2073 healthy=None, 2074 id=None, 2075 name=None, 2076 output=None, 2077 port_override=None, 2078 region=None, 2079 role_arn=None, 2080 role_external_id=None, 2081 secret_access_key=None, 2082 secret_store_id=None, 2083 tags=None, 2084 ): 2085 self.access_key = access_key if access_key is not None else '' 2086 ''' 2087 2088 ''' 2089 self.egress_filter = egress_filter if egress_filter is not None else '' 2090 ''' 2091 A filter applied to the routing logic to pin datasource to nodes. 2092 ''' 2093 self.healthy = healthy if healthy is not None else False 2094 ''' 2095 True if the datasource is reachable and the credentials are valid. 2096 ''' 2097 self.id = id if id is not None else '' 2098 ''' 2099 Unique identifier of the Resource. 2100 ''' 2101 self.name = name if name is not None else '' 2102 ''' 2103 Unique human-readable name of the Resource. 2104 ''' 2105 self.output = output if output is not None else '' 2106 ''' 2107 2108 ''' 2109 self.port_override = port_override if port_override is not None else 0 2110 ''' 2111 2112 ''' 2113 self.region = region if region is not None else '' 2114 ''' 2115 2116 ''' 2117 self.role_arn = role_arn if role_arn is not None else '' 2118 ''' 2119 2120 ''' 2121 self.role_external_id = role_external_id if role_external_id is not None else '' 2122 ''' 2123 2124 ''' 2125 self.secret_access_key = secret_access_key if secret_access_key is not None else '' 2126 ''' 2127 2128 ''' 2129 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 2130 ''' 2131 ID of the secret store containing credentials for this resource, if any. 2132 ''' 2133 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 2134 ''' 2135 Tags is a map of key, value pairs. 2136 '''
#
access_key
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
output
#
port_override
#
region
#
role_arn
#
role_external_id
#
secret_access_key
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
View Source
2155 def to_dict(self): 2156 return { 2157 'access_key': self.access_key, 2158 'egress_filter': self.egress_filter, 2159 'healthy': self.healthy, 2160 'id': self.id, 2161 'name': self.name, 2162 'output': self.output, 2163 'port_override': self.port_override, 2164 'region': self.region, 2165 'role_arn': self.role_arn, 2166 'role_external_id': self.role_external_id, 2167 'secret_access_key': self.secret_access_key, 2168 'secret_store_id': self.secret_store_id, 2169 'tags': self.tags, 2170 }
View Source
2172 @classmethod 2173 def from_dict(cls, d): 2174 return cls( 2175 access_key=d.get('access_key'), 2176 egress_filter=d.get('egress_filter'), 2177 healthy=d.get('healthy'), 2178 id=d.get('id'), 2179 name=d.get('name'), 2180 output=d.get('output'), 2181 port_override=d.get('port_override'), 2182 region=d.get('region'), 2183 role_arn=d.get('role_arn'), 2184 role_external_id=d.get('role_external_id'), 2185 secret_access_key=d.get('secret_access_key'), 2186 secret_store_id=d.get('secret_store_id'), 2187 tags=d.get('tags'), 2188 )
View Source
2191class AuroraMysql: 2192 ''' 2193 2194 ''' 2195 __slots__ = [ 2196 'database', 2197 'egress_filter', 2198 'healthy', 2199 'hostname', 2200 'id', 2201 'name', 2202 'password', 2203 'port', 2204 'port_override', 2205 'secret_store_id', 2206 'tags', 2207 'username', 2208 ] 2209 2210 def __init__( 2211 self, 2212 database=None, 2213 egress_filter=None, 2214 healthy=None, 2215 hostname=None, 2216 id=None, 2217 name=None, 2218 password=None, 2219 port=None, 2220 port_override=None, 2221 secret_store_id=None, 2222 tags=None, 2223 username=None, 2224 ): 2225 self.database = database if database is not None else '' 2226 ''' 2227 2228 ''' 2229 self.egress_filter = egress_filter if egress_filter is not None else '' 2230 ''' 2231 A filter applied to the routing logic to pin datasource to nodes. 2232 ''' 2233 self.healthy = healthy if healthy is not None else False 2234 ''' 2235 True if the datasource is reachable and the credentials are valid. 2236 ''' 2237 self.hostname = hostname if hostname is not None else '' 2238 ''' 2239 2240 ''' 2241 self.id = id if id is not None else '' 2242 ''' 2243 Unique identifier of the Resource. 2244 ''' 2245 self.name = name if name is not None else '' 2246 ''' 2247 Unique human-readable name of the Resource. 2248 ''' 2249 self.password = password if password is not None else '' 2250 ''' 2251 2252 ''' 2253 self.port = port if port is not None else 0 2254 ''' 2255 2256 ''' 2257 self.port_override = port_override if port_override is not None else 0 2258 ''' 2259 2260 ''' 2261 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 2262 ''' 2263 ID of the secret store containing credentials for this resource, if any. 2264 ''' 2265 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 2266 ''' 2267 Tags is a map of key, value pairs. 2268 ''' 2269 self.username = username if username is not None else '' 2270 ''' 2271 2272 ''' 2273 2274 def __repr__(self): 2275 return '<sdm.AuroraMysql ' + \ 2276 'database: ' + repr(self.database) + ' ' +\ 2277 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 2278 'healthy: ' + repr(self.healthy) + ' ' +\ 2279 'hostname: ' + repr(self.hostname) + ' ' +\ 2280 'id: ' + repr(self.id) + ' ' +\ 2281 'name: ' + repr(self.name) + ' ' +\ 2282 'password: ' + repr(self.password) + ' ' +\ 2283 'port: ' + repr(self.port) + ' ' +\ 2284 'port_override: ' + repr(self.port_override) + ' ' +\ 2285 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 2286 'tags: ' + repr(self.tags) + ' ' +\ 2287 'username: ' + repr(self.username) + ' ' +\ 2288 '>' 2289 2290 def to_dict(self): 2291 return { 2292 'database': self.database, 2293 'egress_filter': self.egress_filter, 2294 'healthy': self.healthy, 2295 'hostname': self.hostname, 2296 'id': self.id, 2297 'name': self.name, 2298 'password': self.password, 2299 'port': self.port, 2300 'port_override': self.port_override, 2301 'secret_store_id': self.secret_store_id, 2302 'tags': self.tags, 2303 'username': self.username, 2304 } 2305 2306 @classmethod 2307 def from_dict(cls, d): 2308 return cls( 2309 database=d.get('database'), 2310 egress_filter=d.get('egress_filter'), 2311 healthy=d.get('healthy'), 2312 hostname=d.get('hostname'), 2313 id=d.get('id'), 2314 name=d.get('name'), 2315 password=d.get('password'), 2316 port=d.get('port'), 2317 port_override=d.get('port_override'), 2318 secret_store_id=d.get('secret_store_id'), 2319 tags=d.get('tags'), 2320 username=d.get('username'), 2321 )
#
AuroraMysql(
database=None,
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
password=None,
port=None,
port_override=None,
secret_store_id=None,
tags=None,
username=None
)
View Source
2210 def __init__( 2211 self, 2212 database=None, 2213 egress_filter=None, 2214 healthy=None, 2215 hostname=None, 2216 id=None, 2217 name=None, 2218 password=None, 2219 port=None, 2220 port_override=None, 2221 secret_store_id=None, 2222 tags=None, 2223 username=None, 2224 ): 2225 self.database = database if database is not None else '' 2226 ''' 2227 2228 ''' 2229 self.egress_filter = egress_filter if egress_filter is not None else '' 2230 ''' 2231 A filter applied to the routing logic to pin datasource to nodes. 2232 ''' 2233 self.healthy = healthy if healthy is not None else False 2234 ''' 2235 True if the datasource is reachable and the credentials are valid. 2236 ''' 2237 self.hostname = hostname if hostname is not None else '' 2238 ''' 2239 2240 ''' 2241 self.id = id if id is not None else '' 2242 ''' 2243 Unique identifier of the Resource. 2244 ''' 2245 self.name = name if name is not None else '' 2246 ''' 2247 Unique human-readable name of the Resource. 2248 ''' 2249 self.password = password if password is not None else '' 2250 ''' 2251 2252 ''' 2253 self.port = port if port is not None else 0 2254 ''' 2255 2256 ''' 2257 self.port_override = port_override if port_override is not None else 0 2258 ''' 2259 2260 ''' 2261 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 2262 ''' 2263 ID of the secret store containing credentials for this resource, if any. 2264 ''' 2265 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 2266 ''' 2267 Tags is a map of key, value pairs. 2268 ''' 2269 self.username = username if username is not None else '' 2270 ''' 2271 2272 '''
#
database
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
password
#
port
#
port_override
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
username
View Source
2290 def to_dict(self): 2291 return { 2292 'database': self.database, 2293 'egress_filter': self.egress_filter, 2294 'healthy': self.healthy, 2295 'hostname': self.hostname, 2296 'id': self.id, 2297 'name': self.name, 2298 'password': self.password, 2299 'port': self.port, 2300 'port_override': self.port_override, 2301 'secret_store_id': self.secret_store_id, 2302 'tags': self.tags, 2303 'username': self.username, 2304 }
View Source
2306 @classmethod 2307 def from_dict(cls, d): 2308 return cls( 2309 database=d.get('database'), 2310 egress_filter=d.get('egress_filter'), 2311 healthy=d.get('healthy'), 2312 hostname=d.get('hostname'), 2313 id=d.get('id'), 2314 name=d.get('name'), 2315 password=d.get('password'), 2316 port=d.get('port'), 2317 port_override=d.get('port_override'), 2318 secret_store_id=d.get('secret_store_id'), 2319 tags=d.get('tags'), 2320 username=d.get('username'), 2321 )
View Source
2324class AuroraPostgres: 2325 ''' 2326 2327 ''' 2328 __slots__ = [ 2329 'database', 2330 'egress_filter', 2331 'healthy', 2332 'hostname', 2333 'id', 2334 'name', 2335 'override_database', 2336 'password', 2337 'port', 2338 'port_override', 2339 'secret_store_id', 2340 'tags', 2341 'username', 2342 ] 2343 2344 def __init__( 2345 self, 2346 database=None, 2347 egress_filter=None, 2348 healthy=None, 2349 hostname=None, 2350 id=None, 2351 name=None, 2352 override_database=None, 2353 password=None, 2354 port=None, 2355 port_override=None, 2356 secret_store_id=None, 2357 tags=None, 2358 username=None, 2359 ): 2360 self.database = database if database is not None else '' 2361 ''' 2362 2363 ''' 2364 self.egress_filter = egress_filter if egress_filter is not None else '' 2365 ''' 2366 A filter applied to the routing logic to pin datasource to nodes. 2367 ''' 2368 self.healthy = healthy if healthy is not None else False 2369 ''' 2370 True if the datasource is reachable and the credentials are valid. 2371 ''' 2372 self.hostname = hostname if hostname is not None else '' 2373 ''' 2374 2375 ''' 2376 self.id = id if id is not None else '' 2377 ''' 2378 Unique identifier of the Resource. 2379 ''' 2380 self.name = name if name is not None else '' 2381 ''' 2382 Unique human-readable name of the Resource. 2383 ''' 2384 self.override_database = override_database if override_database is not None else False 2385 ''' 2386 2387 ''' 2388 self.password = password if password is not None else '' 2389 ''' 2390 2391 ''' 2392 self.port = port if port is not None else 0 2393 ''' 2394 2395 ''' 2396 self.port_override = port_override if port_override is not None else 0 2397 ''' 2398 2399 ''' 2400 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 2401 ''' 2402 ID of the secret store containing credentials for this resource, if any. 2403 ''' 2404 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 2405 ''' 2406 Tags is a map of key, value pairs. 2407 ''' 2408 self.username = username if username is not None else '' 2409 ''' 2410 2411 ''' 2412 2413 def __repr__(self): 2414 return '<sdm.AuroraPostgres ' + \ 2415 'database: ' + repr(self.database) + ' ' +\ 2416 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 2417 'healthy: ' + repr(self.healthy) + ' ' +\ 2418 'hostname: ' + repr(self.hostname) + ' ' +\ 2419 'id: ' + repr(self.id) + ' ' +\ 2420 'name: ' + repr(self.name) + ' ' +\ 2421 'override_database: ' + repr(self.override_database) + ' ' +\ 2422 'password: ' + repr(self.password) + ' ' +\ 2423 'port: ' + repr(self.port) + ' ' +\ 2424 'port_override: ' + repr(self.port_override) + ' ' +\ 2425 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 2426 'tags: ' + repr(self.tags) + ' ' +\ 2427 'username: ' + repr(self.username) + ' ' +\ 2428 '>' 2429 2430 def to_dict(self): 2431 return { 2432 'database': self.database, 2433 'egress_filter': self.egress_filter, 2434 'healthy': self.healthy, 2435 'hostname': self.hostname, 2436 'id': self.id, 2437 'name': self.name, 2438 'override_database': self.override_database, 2439 'password': self.password, 2440 'port': self.port, 2441 'port_override': self.port_override, 2442 'secret_store_id': self.secret_store_id, 2443 'tags': self.tags, 2444 'username': self.username, 2445 } 2446 2447 @classmethod 2448 def from_dict(cls, d): 2449 return cls( 2450 database=d.get('database'), 2451 egress_filter=d.get('egress_filter'), 2452 healthy=d.get('healthy'), 2453 hostname=d.get('hostname'), 2454 id=d.get('id'), 2455 name=d.get('name'), 2456 override_database=d.get('override_database'), 2457 password=d.get('password'), 2458 port=d.get('port'), 2459 port_override=d.get('port_override'), 2460 secret_store_id=d.get('secret_store_id'), 2461 tags=d.get('tags'), 2462 username=d.get('username'), 2463 )
#
AuroraPostgres(
database=None,
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
override_database=None,
password=None,
port=None,
port_override=None,
secret_store_id=None,
tags=None,
username=None
)
View Source
2344 def __init__( 2345 self, 2346 database=None, 2347 egress_filter=None, 2348 healthy=None, 2349 hostname=None, 2350 id=None, 2351 name=None, 2352 override_database=None, 2353 password=None, 2354 port=None, 2355 port_override=None, 2356 secret_store_id=None, 2357 tags=None, 2358 username=None, 2359 ): 2360 self.database = database if database is not None else '' 2361 ''' 2362 2363 ''' 2364 self.egress_filter = egress_filter if egress_filter is not None else '' 2365 ''' 2366 A filter applied to the routing logic to pin datasource to nodes. 2367 ''' 2368 self.healthy = healthy if healthy is not None else False 2369 ''' 2370 True if the datasource is reachable and the credentials are valid. 2371 ''' 2372 self.hostname = hostname if hostname is not None else '' 2373 ''' 2374 2375 ''' 2376 self.id = id if id is not None else '' 2377 ''' 2378 Unique identifier of the Resource. 2379 ''' 2380 self.name = name if name is not None else '' 2381 ''' 2382 Unique human-readable name of the Resource. 2383 ''' 2384 self.override_database = override_database if override_database is not None else False 2385 ''' 2386 2387 ''' 2388 self.password = password if password is not None else '' 2389 ''' 2390 2391 ''' 2392 self.port = port if port is not None else 0 2393 ''' 2394 2395 ''' 2396 self.port_override = port_override if port_override is not None else 0 2397 ''' 2398 2399 ''' 2400 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 2401 ''' 2402 ID of the secret store containing credentials for this resource, if any. 2403 ''' 2404 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 2405 ''' 2406 Tags is a map of key, value pairs. 2407 ''' 2408 self.username = username if username is not None else '' 2409 ''' 2410 2411 '''
#
database
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
override_database
#
password
#
port
#
port_override
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
username
View Source
2430 def to_dict(self): 2431 return { 2432 'database': self.database, 2433 'egress_filter': self.egress_filter, 2434 'healthy': self.healthy, 2435 'hostname': self.hostname, 2436 'id': self.id, 2437 'name': self.name, 2438 'override_database': self.override_database, 2439 'password': self.password, 2440 'port': self.port, 2441 'port_override': self.port_override, 2442 'secret_store_id': self.secret_store_id, 2443 'tags': self.tags, 2444 'username': self.username, 2445 }
View Source
2447 @classmethod 2448 def from_dict(cls, d): 2449 return cls( 2450 database=d.get('database'), 2451 egress_filter=d.get('egress_filter'), 2452 healthy=d.get('healthy'), 2453 hostname=d.get('hostname'), 2454 id=d.get('id'), 2455 name=d.get('name'), 2456 override_database=d.get('override_database'), 2457 password=d.get('password'), 2458 port=d.get('port'), 2459 port_override=d.get('port_override'), 2460 secret_store_id=d.get('secret_store_id'), 2461 tags=d.get('tags'), 2462 username=d.get('username'), 2463 )
View Source
2466class Azure: 2467 ''' 2468 2469 ''' 2470 __slots__ = [ 2471 'app_id', 2472 'egress_filter', 2473 'healthy', 2474 'id', 2475 'name', 2476 'password', 2477 'secret_store_id', 2478 'tags', 2479 'tenant_id', 2480 ] 2481 2482 def __init__( 2483 self, 2484 app_id=None, 2485 egress_filter=None, 2486 healthy=None, 2487 id=None, 2488 name=None, 2489 password=None, 2490 secret_store_id=None, 2491 tags=None, 2492 tenant_id=None, 2493 ): 2494 self.app_id = app_id if app_id is not None else '' 2495 ''' 2496 2497 ''' 2498 self.egress_filter = egress_filter if egress_filter is not None else '' 2499 ''' 2500 A filter applied to the routing logic to pin datasource to nodes. 2501 ''' 2502 self.healthy = healthy if healthy is not None else False 2503 ''' 2504 True if the datasource is reachable and the credentials are valid. 2505 ''' 2506 self.id = id if id is not None else '' 2507 ''' 2508 Unique identifier of the Resource. 2509 ''' 2510 self.name = name if name is not None else '' 2511 ''' 2512 Unique human-readable name of the Resource. 2513 ''' 2514 self.password = password if password is not None else '' 2515 ''' 2516 2517 ''' 2518 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 2519 ''' 2520 ID of the secret store containing credentials for this resource, if any. 2521 ''' 2522 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 2523 ''' 2524 Tags is a map of key, value pairs. 2525 ''' 2526 self.tenant_id = tenant_id if tenant_id is not None else '' 2527 ''' 2528 2529 ''' 2530 2531 def __repr__(self): 2532 return '<sdm.Azure ' + \ 2533 'app_id: ' + repr(self.app_id) + ' ' +\ 2534 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 2535 'healthy: ' + repr(self.healthy) + ' ' +\ 2536 'id: ' + repr(self.id) + ' ' +\ 2537 'name: ' + repr(self.name) + ' ' +\ 2538 'password: ' + repr(self.password) + ' ' +\ 2539 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 2540 'tags: ' + repr(self.tags) + ' ' +\ 2541 'tenant_id: ' + repr(self.tenant_id) + ' ' +\ 2542 '>' 2543 2544 def to_dict(self): 2545 return { 2546 'app_id': self.app_id, 2547 'egress_filter': self.egress_filter, 2548 'healthy': self.healthy, 2549 'id': self.id, 2550 'name': self.name, 2551 'password': self.password, 2552 'secret_store_id': self.secret_store_id, 2553 'tags': self.tags, 2554 'tenant_id': self.tenant_id, 2555 } 2556 2557 @classmethod 2558 def from_dict(cls, d): 2559 return cls( 2560 app_id=d.get('app_id'), 2561 egress_filter=d.get('egress_filter'), 2562 healthy=d.get('healthy'), 2563 id=d.get('id'), 2564 name=d.get('name'), 2565 password=d.get('password'), 2566 secret_store_id=d.get('secret_store_id'), 2567 tags=d.get('tags'), 2568 tenant_id=d.get('tenant_id'), 2569 )
#
Azure(
app_id=None,
egress_filter=None,
healthy=None,
id=None,
name=None,
password=None,
secret_store_id=None,
tags=None,
tenant_id=None
)
View Source
2482 def __init__( 2483 self, 2484 app_id=None, 2485 egress_filter=None, 2486 healthy=None, 2487 id=None, 2488 name=None, 2489 password=None, 2490 secret_store_id=None, 2491 tags=None, 2492 tenant_id=None, 2493 ): 2494 self.app_id = app_id if app_id is not None else '' 2495 ''' 2496 2497 ''' 2498 self.egress_filter = egress_filter if egress_filter is not None else '' 2499 ''' 2500 A filter applied to the routing logic to pin datasource to nodes. 2501 ''' 2502 self.healthy = healthy if healthy is not None else False 2503 ''' 2504 True if the datasource is reachable and the credentials are valid. 2505 ''' 2506 self.id = id if id is not None else '' 2507 ''' 2508 Unique identifier of the Resource. 2509 ''' 2510 self.name = name if name is not None else '' 2511 ''' 2512 Unique human-readable name of the Resource. 2513 ''' 2514 self.password = password if password is not None else '' 2515 ''' 2516 2517 ''' 2518 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 2519 ''' 2520 ID of the secret store containing credentials for this resource, if any. 2521 ''' 2522 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 2523 ''' 2524 Tags is a map of key, value pairs. 2525 ''' 2526 self.tenant_id = tenant_id if tenant_id is not None else '' 2527 ''' 2528 2529 '''
#
app_id
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
password
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
tenant_id
View Source
2544 def to_dict(self): 2545 return { 2546 'app_id': self.app_id, 2547 'egress_filter': self.egress_filter, 2548 'healthy': self.healthy, 2549 'id': self.id, 2550 'name': self.name, 2551 'password': self.password, 2552 'secret_store_id': self.secret_store_id, 2553 'tags': self.tags, 2554 'tenant_id': self.tenant_id, 2555 }
View Source
2557 @classmethod 2558 def from_dict(cls, d): 2559 return cls( 2560 app_id=d.get('app_id'), 2561 egress_filter=d.get('egress_filter'), 2562 healthy=d.get('healthy'), 2563 id=d.get('id'), 2564 name=d.get('name'), 2565 password=d.get('password'), 2566 secret_store_id=d.get('secret_store_id'), 2567 tags=d.get('tags'), 2568 tenant_id=d.get('tenant_id'), 2569 )
View Source
2572class AzureCertificate: 2573 ''' 2574 2575 ''' 2576 __slots__ = [ 2577 'app_id', 2578 'client_certificate', 2579 'egress_filter', 2580 'healthy', 2581 'id', 2582 'name', 2583 'secret_store_id', 2584 'tags', 2585 'tenant_id', 2586 ] 2587 2588 def __init__( 2589 self, 2590 app_id=None, 2591 client_certificate=None, 2592 egress_filter=None, 2593 healthy=None, 2594 id=None, 2595 name=None, 2596 secret_store_id=None, 2597 tags=None, 2598 tenant_id=None, 2599 ): 2600 self.app_id = app_id if app_id is not None else '' 2601 ''' 2602 2603 ''' 2604 self.client_certificate = client_certificate if client_certificate is not None else '' 2605 ''' 2606 2607 ''' 2608 self.egress_filter = egress_filter if egress_filter is not None else '' 2609 ''' 2610 A filter applied to the routing logic to pin datasource to nodes. 2611 ''' 2612 self.healthy = healthy if healthy is not None else False 2613 ''' 2614 True if the datasource is reachable and the credentials are valid. 2615 ''' 2616 self.id = id if id is not None else '' 2617 ''' 2618 Unique identifier of the Resource. 2619 ''' 2620 self.name = name if name is not None else '' 2621 ''' 2622 Unique human-readable name of the Resource. 2623 ''' 2624 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 2625 ''' 2626 ID of the secret store containing credentials for this resource, if any. 2627 ''' 2628 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 2629 ''' 2630 Tags is a map of key, value pairs. 2631 ''' 2632 self.tenant_id = tenant_id if tenant_id is not None else '' 2633 ''' 2634 2635 ''' 2636 2637 def __repr__(self): 2638 return '<sdm.AzureCertificate ' + \ 2639 'app_id: ' + repr(self.app_id) + ' ' +\ 2640 'client_certificate: ' + repr(self.client_certificate) + ' ' +\ 2641 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 2642 'healthy: ' + repr(self.healthy) + ' ' +\ 2643 'id: ' + repr(self.id) + ' ' +\ 2644 'name: ' + repr(self.name) + ' ' +\ 2645 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 2646 'tags: ' + repr(self.tags) + ' ' +\ 2647 'tenant_id: ' + repr(self.tenant_id) + ' ' +\ 2648 '>' 2649 2650 def to_dict(self): 2651 return { 2652 'app_id': self.app_id, 2653 'client_certificate': self.client_certificate, 2654 'egress_filter': self.egress_filter, 2655 'healthy': self.healthy, 2656 'id': self.id, 2657 'name': self.name, 2658 'secret_store_id': self.secret_store_id, 2659 'tags': self.tags, 2660 'tenant_id': self.tenant_id, 2661 } 2662 2663 @classmethod 2664 def from_dict(cls, d): 2665 return cls( 2666 app_id=d.get('app_id'), 2667 client_certificate=d.get('client_certificate'), 2668 egress_filter=d.get('egress_filter'), 2669 healthy=d.get('healthy'), 2670 id=d.get('id'), 2671 name=d.get('name'), 2672 secret_store_id=d.get('secret_store_id'), 2673 tags=d.get('tags'), 2674 tenant_id=d.get('tenant_id'), 2675 )
#
AzureCertificate(
app_id=None,
client_certificate=None,
egress_filter=None,
healthy=None,
id=None,
name=None,
secret_store_id=None,
tags=None,
tenant_id=None
)
View Source
2588 def __init__( 2589 self, 2590 app_id=None, 2591 client_certificate=None, 2592 egress_filter=None, 2593 healthy=None, 2594 id=None, 2595 name=None, 2596 secret_store_id=None, 2597 tags=None, 2598 tenant_id=None, 2599 ): 2600 self.app_id = app_id if app_id is not None else '' 2601 ''' 2602 2603 ''' 2604 self.client_certificate = client_certificate if client_certificate is not None else '' 2605 ''' 2606 2607 ''' 2608 self.egress_filter = egress_filter if egress_filter is not None else '' 2609 ''' 2610 A filter applied to the routing logic to pin datasource to nodes. 2611 ''' 2612 self.healthy = healthy if healthy is not None else False 2613 ''' 2614 True if the datasource is reachable and the credentials are valid. 2615 ''' 2616 self.id = id if id is not None else '' 2617 ''' 2618 Unique identifier of the Resource. 2619 ''' 2620 self.name = name if name is not None else '' 2621 ''' 2622 Unique human-readable name of the Resource. 2623 ''' 2624 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 2625 ''' 2626 ID of the secret store containing credentials for this resource, if any. 2627 ''' 2628 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 2629 ''' 2630 Tags is a map of key, value pairs. 2631 ''' 2632 self.tenant_id = tenant_id if tenant_id is not None else '' 2633 ''' 2634 2635 '''
#
app_id
#
client_certificate
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
tenant_id
View Source
2650 def to_dict(self): 2651 return { 2652 'app_id': self.app_id, 2653 'client_certificate': self.client_certificate, 2654 'egress_filter': self.egress_filter, 2655 'healthy': self.healthy, 2656 'id': self.id, 2657 'name': self.name, 2658 'secret_store_id': self.secret_store_id, 2659 'tags': self.tags, 2660 'tenant_id': self.tenant_id, 2661 }
View Source
2663 @classmethod 2664 def from_dict(cls, d): 2665 return cls( 2666 app_id=d.get('app_id'), 2667 client_certificate=d.get('client_certificate'), 2668 egress_filter=d.get('egress_filter'), 2669 healthy=d.get('healthy'), 2670 id=d.get('id'), 2671 name=d.get('name'), 2672 secret_store_id=d.get('secret_store_id'), 2673 tags=d.get('tags'), 2674 tenant_id=d.get('tenant_id'), 2675 )
View Source
2678class AzurePostgres: 2679 ''' 2680 2681 ''' 2682 __slots__ = [ 2683 'database', 2684 'egress_filter', 2685 'healthy', 2686 'hostname', 2687 'id', 2688 'name', 2689 'override_database', 2690 'password', 2691 'port', 2692 'port_override', 2693 'secret_store_id', 2694 'tags', 2695 'username', 2696 ] 2697 2698 def __init__( 2699 self, 2700 database=None, 2701 egress_filter=None, 2702 healthy=None, 2703 hostname=None, 2704 id=None, 2705 name=None, 2706 override_database=None, 2707 password=None, 2708 port=None, 2709 port_override=None, 2710 secret_store_id=None, 2711 tags=None, 2712 username=None, 2713 ): 2714 self.database = database if database is not None else '' 2715 ''' 2716 2717 ''' 2718 self.egress_filter = egress_filter if egress_filter is not None else '' 2719 ''' 2720 A filter applied to the routing logic to pin datasource to nodes. 2721 ''' 2722 self.healthy = healthy if healthy is not None else False 2723 ''' 2724 True if the datasource is reachable and the credentials are valid. 2725 ''' 2726 self.hostname = hostname if hostname is not None else '' 2727 ''' 2728 2729 ''' 2730 self.id = id if id is not None else '' 2731 ''' 2732 Unique identifier of the Resource. 2733 ''' 2734 self.name = name if name is not None else '' 2735 ''' 2736 Unique human-readable name of the Resource. 2737 ''' 2738 self.override_database = override_database if override_database is not None else False 2739 ''' 2740 2741 ''' 2742 self.password = password if password is not None else '' 2743 ''' 2744 2745 ''' 2746 self.port = port if port is not None else 0 2747 ''' 2748 2749 ''' 2750 self.port_override = port_override if port_override is not None else 0 2751 ''' 2752 2753 ''' 2754 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 2755 ''' 2756 ID of the secret store containing credentials for this resource, if any. 2757 ''' 2758 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 2759 ''' 2760 Tags is a map of key, value pairs. 2761 ''' 2762 self.username = username if username is not None else '' 2763 ''' 2764 2765 ''' 2766 2767 def __repr__(self): 2768 return '<sdm.AzurePostgres ' + \ 2769 'database: ' + repr(self.database) + ' ' +\ 2770 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 2771 'healthy: ' + repr(self.healthy) + ' ' +\ 2772 'hostname: ' + repr(self.hostname) + ' ' +\ 2773 'id: ' + repr(self.id) + ' ' +\ 2774 'name: ' + repr(self.name) + ' ' +\ 2775 'override_database: ' + repr(self.override_database) + ' ' +\ 2776 'password: ' + repr(self.password) + ' ' +\ 2777 'port: ' + repr(self.port) + ' ' +\ 2778 'port_override: ' + repr(self.port_override) + ' ' +\ 2779 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 2780 'tags: ' + repr(self.tags) + ' ' +\ 2781 'username: ' + repr(self.username) + ' ' +\ 2782 '>' 2783 2784 def to_dict(self): 2785 return { 2786 'database': self.database, 2787 'egress_filter': self.egress_filter, 2788 'healthy': self.healthy, 2789 'hostname': self.hostname, 2790 'id': self.id, 2791 'name': self.name, 2792 'override_database': self.override_database, 2793 'password': self.password, 2794 'port': self.port, 2795 'port_override': self.port_override, 2796 'secret_store_id': self.secret_store_id, 2797 'tags': self.tags, 2798 'username': self.username, 2799 } 2800 2801 @classmethod 2802 def from_dict(cls, d): 2803 return cls( 2804 database=d.get('database'), 2805 egress_filter=d.get('egress_filter'), 2806 healthy=d.get('healthy'), 2807 hostname=d.get('hostname'), 2808 id=d.get('id'), 2809 name=d.get('name'), 2810 override_database=d.get('override_database'), 2811 password=d.get('password'), 2812 port=d.get('port'), 2813 port_override=d.get('port_override'), 2814 secret_store_id=d.get('secret_store_id'), 2815 tags=d.get('tags'), 2816 username=d.get('username'), 2817 )
#
AzurePostgres(
database=None,
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
override_database=None,
password=None,
port=None,
port_override=None,
secret_store_id=None,
tags=None,
username=None
)
View Source
2698 def __init__( 2699 self, 2700 database=None, 2701 egress_filter=None, 2702 healthy=None, 2703 hostname=None, 2704 id=None, 2705 name=None, 2706 override_database=None, 2707 password=None, 2708 port=None, 2709 port_override=None, 2710 secret_store_id=None, 2711 tags=None, 2712 username=None, 2713 ): 2714 self.database = database if database is not None else '' 2715 ''' 2716 2717 ''' 2718 self.egress_filter = egress_filter if egress_filter is not None else '' 2719 ''' 2720 A filter applied to the routing logic to pin datasource to nodes. 2721 ''' 2722 self.healthy = healthy if healthy is not None else False 2723 ''' 2724 True if the datasource is reachable and the credentials are valid. 2725 ''' 2726 self.hostname = hostname if hostname is not None else '' 2727 ''' 2728 2729 ''' 2730 self.id = id if id is not None else '' 2731 ''' 2732 Unique identifier of the Resource. 2733 ''' 2734 self.name = name if name is not None else '' 2735 ''' 2736 Unique human-readable name of the Resource. 2737 ''' 2738 self.override_database = override_database if override_database is not None else False 2739 ''' 2740 2741 ''' 2742 self.password = password if password is not None else '' 2743 ''' 2744 2745 ''' 2746 self.port = port if port is not None else 0 2747 ''' 2748 2749 ''' 2750 self.port_override = port_override if port_override is not None else 0 2751 ''' 2752 2753 ''' 2754 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 2755 ''' 2756 ID of the secret store containing credentials for this resource, if any. 2757 ''' 2758 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 2759 ''' 2760 Tags is a map of key, value pairs. 2761 ''' 2762 self.username = username if username is not None else '' 2763 ''' 2764 2765 '''
#
database
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
override_database
#
password
#
port
#
port_override
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
username
View Source
2784 def to_dict(self): 2785 return { 2786 'database': self.database, 2787 'egress_filter': self.egress_filter, 2788 'healthy': self.healthy, 2789 'hostname': self.hostname, 2790 'id': self.id, 2791 'name': self.name, 2792 'override_database': self.override_database, 2793 'password': self.password, 2794 'port': self.port, 2795 'port_override': self.port_override, 2796 'secret_store_id': self.secret_store_id, 2797 'tags': self.tags, 2798 'username': self.username, 2799 }
View Source
2801 @classmethod 2802 def from_dict(cls, d): 2803 return cls( 2804 database=d.get('database'), 2805 egress_filter=d.get('egress_filter'), 2806 healthy=d.get('healthy'), 2807 hostname=d.get('hostname'), 2808 id=d.get('id'), 2809 name=d.get('name'), 2810 override_database=d.get('override_database'), 2811 password=d.get('password'), 2812 port=d.get('port'), 2813 port_override=d.get('port_override'), 2814 secret_store_id=d.get('secret_store_id'), 2815 tags=d.get('tags'), 2816 username=d.get('username'), 2817 )
View Source
2820class AzureStore: 2821 ''' 2822 2823 ''' 2824 __slots__ = [ 2825 'id', 2826 'name', 2827 'tags', 2828 'vault_uri', 2829 ] 2830 2831 def __init__( 2832 self, 2833 id=None, 2834 name=None, 2835 tags=None, 2836 vault_uri=None, 2837 ): 2838 self.id = id if id is not None else '' 2839 ''' 2840 Unique identifier of the SecretStore. 2841 ''' 2842 self.name = name if name is not None else '' 2843 ''' 2844 Unique human-readable name of the SecretStore. 2845 ''' 2846 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 2847 ''' 2848 Tags is a map of key, value pairs. 2849 ''' 2850 self.vault_uri = vault_uri if vault_uri is not None else '' 2851 ''' 2852 2853 ''' 2854 2855 def __repr__(self): 2856 return '<sdm.AzureStore ' + \ 2857 'id: ' + repr(self.id) + ' ' +\ 2858 'name: ' + repr(self.name) + ' ' +\ 2859 'tags: ' + repr(self.tags) + ' ' +\ 2860 'vault_uri: ' + repr(self.vault_uri) + ' ' +\ 2861 '>' 2862 2863 def to_dict(self): 2864 return { 2865 'id': self.id, 2866 'name': self.name, 2867 'tags': self.tags, 2868 'vault_uri': self.vault_uri, 2869 } 2870 2871 @classmethod 2872 def from_dict(cls, d): 2873 return cls( 2874 id=d.get('id'), 2875 name=d.get('name'), 2876 tags=d.get('tags'), 2877 vault_uri=d.get('vault_uri'), 2878 )
View Source
2831 def __init__( 2832 self, 2833 id=None, 2834 name=None, 2835 tags=None, 2836 vault_uri=None, 2837 ): 2838 self.id = id if id is not None else '' 2839 ''' 2840 Unique identifier of the SecretStore. 2841 ''' 2842 self.name = name if name is not None else '' 2843 ''' 2844 Unique human-readable name of the SecretStore. 2845 ''' 2846 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 2847 ''' 2848 Tags is a map of key, value pairs. 2849 ''' 2850 self.vault_uri = vault_uri if vault_uri is not None else '' 2851 ''' 2852 2853 '''
#
id
Unique identifier of the SecretStore.
#
name
Unique human-readable name of the SecretStore.
#
vault_uri
View Source
2881class BigQuery: 2882 ''' 2883 2884 ''' 2885 __slots__ = [ 2886 'egress_filter', 2887 'endpoint', 2888 'healthy', 2889 'id', 2890 'name', 2891 'port_override', 2892 'private_key', 2893 'project', 2894 'secret_store_id', 2895 'tags', 2896 'username', 2897 ] 2898 2899 def __init__( 2900 self, 2901 egress_filter=None, 2902 endpoint=None, 2903 healthy=None, 2904 id=None, 2905 name=None, 2906 port_override=None, 2907 private_key=None, 2908 project=None, 2909 secret_store_id=None, 2910 tags=None, 2911 username=None, 2912 ): 2913 self.egress_filter = egress_filter if egress_filter is not None else '' 2914 ''' 2915 A filter applied to the routing logic to pin datasource to nodes. 2916 ''' 2917 self.endpoint = endpoint if endpoint is not None else '' 2918 ''' 2919 2920 ''' 2921 self.healthy = healthy if healthy is not None else False 2922 ''' 2923 True if the datasource is reachable and the credentials are valid. 2924 ''' 2925 self.id = id if id is not None else '' 2926 ''' 2927 Unique identifier of the Resource. 2928 ''' 2929 self.name = name if name is not None else '' 2930 ''' 2931 Unique human-readable name of the Resource. 2932 ''' 2933 self.port_override = port_override if port_override is not None else 0 2934 ''' 2935 2936 ''' 2937 self.private_key = private_key if private_key is not None else '' 2938 ''' 2939 2940 ''' 2941 self.project = project if project is not None else '' 2942 ''' 2943 2944 ''' 2945 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 2946 ''' 2947 ID of the secret store containing credentials for this resource, if any. 2948 ''' 2949 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 2950 ''' 2951 Tags is a map of key, value pairs. 2952 ''' 2953 self.username = username if username is not None else '' 2954 ''' 2955 2956 ''' 2957 2958 def __repr__(self): 2959 return '<sdm.BigQuery ' + \ 2960 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 2961 'endpoint: ' + repr(self.endpoint) + ' ' +\ 2962 'healthy: ' + repr(self.healthy) + ' ' +\ 2963 'id: ' + repr(self.id) + ' ' +\ 2964 'name: ' + repr(self.name) + ' ' +\ 2965 'port_override: ' + repr(self.port_override) + ' ' +\ 2966 'private_key: ' + repr(self.private_key) + ' ' +\ 2967 'project: ' + repr(self.project) + ' ' +\ 2968 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 2969 'tags: ' + repr(self.tags) + ' ' +\ 2970 'username: ' + repr(self.username) + ' ' +\ 2971 '>' 2972 2973 def to_dict(self): 2974 return { 2975 'egress_filter': self.egress_filter, 2976 'endpoint': self.endpoint, 2977 'healthy': self.healthy, 2978 'id': self.id, 2979 'name': self.name, 2980 'port_override': self.port_override, 2981 'private_key': self.private_key, 2982 'project': self.project, 2983 'secret_store_id': self.secret_store_id, 2984 'tags': self.tags, 2985 'username': self.username, 2986 } 2987 2988 @classmethod 2989 def from_dict(cls, d): 2990 return cls( 2991 egress_filter=d.get('egress_filter'), 2992 endpoint=d.get('endpoint'), 2993 healthy=d.get('healthy'), 2994 id=d.get('id'), 2995 name=d.get('name'), 2996 port_override=d.get('port_override'), 2997 private_key=d.get('private_key'), 2998 project=d.get('project'), 2999 secret_store_id=d.get('secret_store_id'), 3000 tags=d.get('tags'), 3001 username=d.get('username'), 3002 )
#
BigQuery(
egress_filter=None,
endpoint=None,
healthy=None,
id=None,
name=None,
port_override=None,
private_key=None,
project=None,
secret_store_id=None,
tags=None,
username=None
)
View Source
2899 def __init__( 2900 self, 2901 egress_filter=None, 2902 endpoint=None, 2903 healthy=None, 2904 id=None, 2905 name=None, 2906 port_override=None, 2907 private_key=None, 2908 project=None, 2909 secret_store_id=None, 2910 tags=None, 2911 username=None, 2912 ): 2913 self.egress_filter = egress_filter if egress_filter is not None else '' 2914 ''' 2915 A filter applied to the routing logic to pin datasource to nodes. 2916 ''' 2917 self.endpoint = endpoint if endpoint is not None else '' 2918 ''' 2919 2920 ''' 2921 self.healthy = healthy if healthy is not None else False 2922 ''' 2923 True if the datasource is reachable and the credentials are valid. 2924 ''' 2925 self.id = id if id is not None else '' 2926 ''' 2927 Unique identifier of the Resource. 2928 ''' 2929 self.name = name if name is not None else '' 2930 ''' 2931 Unique human-readable name of the Resource. 2932 ''' 2933 self.port_override = port_override if port_override is not None else 0 2934 ''' 2935 2936 ''' 2937 self.private_key = private_key if private_key is not None else '' 2938 ''' 2939 2940 ''' 2941 self.project = project if project is not None else '' 2942 ''' 2943 2944 ''' 2945 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 2946 ''' 2947 ID of the secret store containing credentials for this resource, if any. 2948 ''' 2949 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 2950 ''' 2951 Tags is a map of key, value pairs. 2952 ''' 2953 self.username = username if username is not None else '' 2954 ''' 2955 2956 '''
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
endpoint
#
healthy
True if the datasource is reachable and the credentials are valid.
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
port_override
#
private_key
#
project
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
username
View Source
2973 def to_dict(self): 2974 return { 2975 'egress_filter': self.egress_filter, 2976 'endpoint': self.endpoint, 2977 'healthy': self.healthy, 2978 'id': self.id, 2979 'name': self.name, 2980 'port_override': self.port_override, 2981 'private_key': self.private_key, 2982 'project': self.project, 2983 'secret_store_id': self.secret_store_id, 2984 'tags': self.tags, 2985 'username': self.username, 2986 }
View Source
2988 @classmethod 2989 def from_dict(cls, d): 2990 return cls( 2991 egress_filter=d.get('egress_filter'), 2992 endpoint=d.get('endpoint'), 2993 healthy=d.get('healthy'), 2994 id=d.get('id'), 2995 name=d.get('name'), 2996 port_override=d.get('port_override'), 2997 private_key=d.get('private_key'), 2998 project=d.get('project'), 2999 secret_store_id=d.get('secret_store_id'), 3000 tags=d.get('tags'), 3001 username=d.get('username'), 3002 )
View Source
3005class Cassandra: 3006 ''' 3007 3008 ''' 3009 __slots__ = [ 3010 'egress_filter', 3011 'healthy', 3012 'hostname', 3013 'id', 3014 'name', 3015 'password', 3016 'port', 3017 'port_override', 3018 'secret_store_id', 3019 'tags', 3020 'tls_required', 3021 'username', 3022 ] 3023 3024 def __init__( 3025 self, 3026 egress_filter=None, 3027 healthy=None, 3028 hostname=None, 3029 id=None, 3030 name=None, 3031 password=None, 3032 port=None, 3033 port_override=None, 3034 secret_store_id=None, 3035 tags=None, 3036 tls_required=None, 3037 username=None, 3038 ): 3039 self.egress_filter = egress_filter if egress_filter is not None else '' 3040 ''' 3041 A filter applied to the routing logic to pin datasource to nodes. 3042 ''' 3043 self.healthy = healthy if healthy is not None else False 3044 ''' 3045 True if the datasource is reachable and the credentials are valid. 3046 ''' 3047 self.hostname = hostname if hostname is not None else '' 3048 ''' 3049 3050 ''' 3051 self.id = id if id is not None else '' 3052 ''' 3053 Unique identifier of the Resource. 3054 ''' 3055 self.name = name if name is not None else '' 3056 ''' 3057 Unique human-readable name of the Resource. 3058 ''' 3059 self.password = password if password is not None else '' 3060 ''' 3061 3062 ''' 3063 self.port = port if port is not None else 0 3064 ''' 3065 3066 ''' 3067 self.port_override = port_override if port_override is not None else 0 3068 ''' 3069 3070 ''' 3071 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 3072 ''' 3073 ID of the secret store containing credentials for this resource, if any. 3074 ''' 3075 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 3076 ''' 3077 Tags is a map of key, value pairs. 3078 ''' 3079 self.tls_required = tls_required if tls_required is not None else False 3080 ''' 3081 3082 ''' 3083 self.username = username if username is not None else '' 3084 ''' 3085 3086 ''' 3087 3088 def __repr__(self): 3089 return '<sdm.Cassandra ' + \ 3090 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 3091 'healthy: ' + repr(self.healthy) + ' ' +\ 3092 'hostname: ' + repr(self.hostname) + ' ' +\ 3093 'id: ' + repr(self.id) + ' ' +\ 3094 'name: ' + repr(self.name) + ' ' +\ 3095 'password: ' + repr(self.password) + ' ' +\ 3096 'port: ' + repr(self.port) + ' ' +\ 3097 'port_override: ' + repr(self.port_override) + ' ' +\ 3098 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 3099 'tags: ' + repr(self.tags) + ' ' +\ 3100 'tls_required: ' + repr(self.tls_required) + ' ' +\ 3101 'username: ' + repr(self.username) + ' ' +\ 3102 '>' 3103 3104 def to_dict(self): 3105 return { 3106 'egress_filter': self.egress_filter, 3107 'healthy': self.healthy, 3108 'hostname': self.hostname, 3109 'id': self.id, 3110 'name': self.name, 3111 'password': self.password, 3112 'port': self.port, 3113 'port_override': self.port_override, 3114 'secret_store_id': self.secret_store_id, 3115 'tags': self.tags, 3116 'tls_required': self.tls_required, 3117 'username': self.username, 3118 } 3119 3120 @classmethod 3121 def from_dict(cls, d): 3122 return cls( 3123 egress_filter=d.get('egress_filter'), 3124 healthy=d.get('healthy'), 3125 hostname=d.get('hostname'), 3126 id=d.get('id'), 3127 name=d.get('name'), 3128 password=d.get('password'), 3129 port=d.get('port'), 3130 port_override=d.get('port_override'), 3131 secret_store_id=d.get('secret_store_id'), 3132 tags=d.get('tags'), 3133 tls_required=d.get('tls_required'), 3134 username=d.get('username'), 3135 )
#
Cassandra(
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
password=None,
port=None,
port_override=None,
secret_store_id=None,
tags=None,
tls_required=None,
username=None
)
View Source
3024 def __init__( 3025 self, 3026 egress_filter=None, 3027 healthy=None, 3028 hostname=None, 3029 id=None, 3030 name=None, 3031 password=None, 3032 port=None, 3033 port_override=None, 3034 secret_store_id=None, 3035 tags=None, 3036 tls_required=None, 3037 username=None, 3038 ): 3039 self.egress_filter = egress_filter if egress_filter is not None else '' 3040 ''' 3041 A filter applied to the routing logic to pin datasource to nodes. 3042 ''' 3043 self.healthy = healthy if healthy is not None else False 3044 ''' 3045 True if the datasource is reachable and the credentials are valid. 3046 ''' 3047 self.hostname = hostname if hostname is not None else '' 3048 ''' 3049 3050 ''' 3051 self.id = id if id is not None else '' 3052 ''' 3053 Unique identifier of the Resource. 3054 ''' 3055 self.name = name if name is not None else '' 3056 ''' 3057 Unique human-readable name of the Resource. 3058 ''' 3059 self.password = password if password is not None else '' 3060 ''' 3061 3062 ''' 3063 self.port = port if port is not None else 0 3064 ''' 3065 3066 ''' 3067 self.port_override = port_override if port_override is not None else 0 3068 ''' 3069 3070 ''' 3071 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 3072 ''' 3073 ID of the secret store containing credentials for this resource, if any. 3074 ''' 3075 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 3076 ''' 3077 Tags is a map of key, value pairs. 3078 ''' 3079 self.tls_required = tls_required if tls_required is not None else False 3080 ''' 3081 3082 ''' 3083 self.username = username if username is not None else '' 3084 ''' 3085 3086 '''
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
password
#
port
#
port_override
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
tls_required
#
username
View Source
3104 def to_dict(self): 3105 return { 3106 'egress_filter': self.egress_filter, 3107 'healthy': self.healthy, 3108 'hostname': self.hostname, 3109 'id': self.id, 3110 'name': self.name, 3111 'password': self.password, 3112 'port': self.port, 3113 'port_override': self.port_override, 3114 'secret_store_id': self.secret_store_id, 3115 'tags': self.tags, 3116 'tls_required': self.tls_required, 3117 'username': self.username, 3118 }
View Source
3120 @classmethod 3121 def from_dict(cls, d): 3122 return cls( 3123 egress_filter=d.get('egress_filter'), 3124 healthy=d.get('healthy'), 3125 hostname=d.get('hostname'), 3126 id=d.get('id'), 3127 name=d.get('name'), 3128 password=d.get('password'), 3129 port=d.get('port'), 3130 port_override=d.get('port_override'), 3131 secret_store_id=d.get('secret_store_id'), 3132 tags=d.get('tags'), 3133 tls_required=d.get('tls_required'), 3134 username=d.get('username'), 3135 )
View Source
3138class Citus: 3139 ''' 3140 3141 ''' 3142 __slots__ = [ 3143 'database', 3144 'egress_filter', 3145 'healthy', 3146 'hostname', 3147 'id', 3148 'name', 3149 'override_database', 3150 'password', 3151 'port', 3152 'port_override', 3153 'secret_store_id', 3154 'tags', 3155 'username', 3156 ] 3157 3158 def __init__( 3159 self, 3160 database=None, 3161 egress_filter=None, 3162 healthy=None, 3163 hostname=None, 3164 id=None, 3165 name=None, 3166 override_database=None, 3167 password=None, 3168 port=None, 3169 port_override=None, 3170 secret_store_id=None, 3171 tags=None, 3172 username=None, 3173 ): 3174 self.database = database if database is not None else '' 3175 ''' 3176 3177 ''' 3178 self.egress_filter = egress_filter if egress_filter is not None else '' 3179 ''' 3180 A filter applied to the routing logic to pin datasource to nodes. 3181 ''' 3182 self.healthy = healthy if healthy is not None else False 3183 ''' 3184 True if the datasource is reachable and the credentials are valid. 3185 ''' 3186 self.hostname = hostname if hostname is not None else '' 3187 ''' 3188 3189 ''' 3190 self.id = id if id is not None else '' 3191 ''' 3192 Unique identifier of the Resource. 3193 ''' 3194 self.name = name if name is not None else '' 3195 ''' 3196 Unique human-readable name of the Resource. 3197 ''' 3198 self.override_database = override_database if override_database is not None else False 3199 ''' 3200 3201 ''' 3202 self.password = password if password is not None else '' 3203 ''' 3204 3205 ''' 3206 self.port = port if port is not None else 0 3207 ''' 3208 3209 ''' 3210 self.port_override = port_override if port_override is not None else 0 3211 ''' 3212 3213 ''' 3214 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 3215 ''' 3216 ID of the secret store containing credentials for this resource, if any. 3217 ''' 3218 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 3219 ''' 3220 Tags is a map of key, value pairs. 3221 ''' 3222 self.username = username if username is not None else '' 3223 ''' 3224 3225 ''' 3226 3227 def __repr__(self): 3228 return '<sdm.Citus ' + \ 3229 'database: ' + repr(self.database) + ' ' +\ 3230 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 3231 'healthy: ' + repr(self.healthy) + ' ' +\ 3232 'hostname: ' + repr(self.hostname) + ' ' +\ 3233 'id: ' + repr(self.id) + ' ' +\ 3234 'name: ' + repr(self.name) + ' ' +\ 3235 'override_database: ' + repr(self.override_database) + ' ' +\ 3236 'password: ' + repr(self.password) + ' ' +\ 3237 'port: ' + repr(self.port) + ' ' +\ 3238 'port_override: ' + repr(self.port_override) + ' ' +\ 3239 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 3240 'tags: ' + repr(self.tags) + ' ' +\ 3241 'username: ' + repr(self.username) + ' ' +\ 3242 '>' 3243 3244 def to_dict(self): 3245 return { 3246 'database': self.database, 3247 'egress_filter': self.egress_filter, 3248 'healthy': self.healthy, 3249 'hostname': self.hostname, 3250 'id': self.id, 3251 'name': self.name, 3252 'override_database': self.override_database, 3253 'password': self.password, 3254 'port': self.port, 3255 'port_override': self.port_override, 3256 'secret_store_id': self.secret_store_id, 3257 'tags': self.tags, 3258 'username': self.username, 3259 } 3260 3261 @classmethod 3262 def from_dict(cls, d): 3263 return cls( 3264 database=d.get('database'), 3265 egress_filter=d.get('egress_filter'), 3266 healthy=d.get('healthy'), 3267 hostname=d.get('hostname'), 3268 id=d.get('id'), 3269 name=d.get('name'), 3270 override_database=d.get('override_database'), 3271 password=d.get('password'), 3272 port=d.get('port'), 3273 port_override=d.get('port_override'), 3274 secret_store_id=d.get('secret_store_id'), 3275 tags=d.get('tags'), 3276 username=d.get('username'), 3277 )
#
Citus(
database=None,
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
override_database=None,
password=None,
port=None,
port_override=None,
secret_store_id=None,
tags=None,
username=None
)
View Source
3158 def __init__( 3159 self, 3160 database=None, 3161 egress_filter=None, 3162 healthy=None, 3163 hostname=None, 3164 id=None, 3165 name=None, 3166 override_database=None, 3167 password=None, 3168 port=None, 3169 port_override=None, 3170 secret_store_id=None, 3171 tags=None, 3172 username=None, 3173 ): 3174 self.database = database if database is not None else '' 3175 ''' 3176 3177 ''' 3178 self.egress_filter = egress_filter if egress_filter is not None else '' 3179 ''' 3180 A filter applied to the routing logic to pin datasource to nodes. 3181 ''' 3182 self.healthy = healthy if healthy is not None else False 3183 ''' 3184 True if the datasource is reachable and the credentials are valid. 3185 ''' 3186 self.hostname = hostname if hostname is not None else '' 3187 ''' 3188 3189 ''' 3190 self.id = id if id is not None else '' 3191 ''' 3192 Unique identifier of the Resource. 3193 ''' 3194 self.name = name if name is not None else '' 3195 ''' 3196 Unique human-readable name of the Resource. 3197 ''' 3198 self.override_database = override_database if override_database is not None else False 3199 ''' 3200 3201 ''' 3202 self.password = password if password is not None else '' 3203 ''' 3204 3205 ''' 3206 self.port = port if port is not None else 0 3207 ''' 3208 3209 ''' 3210 self.port_override = port_override if port_override is not None else 0 3211 ''' 3212 3213 ''' 3214 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 3215 ''' 3216 ID of the secret store containing credentials for this resource, if any. 3217 ''' 3218 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 3219 ''' 3220 Tags is a map of key, value pairs. 3221 ''' 3222 self.username = username if username is not None else '' 3223 ''' 3224 3225 '''
#
database
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
override_database
#
password
#
port
#
port_override
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
username
View Source
3244 def to_dict(self): 3245 return { 3246 'database': self.database, 3247 'egress_filter': self.egress_filter, 3248 'healthy': self.healthy, 3249 'hostname': self.hostname, 3250 'id': self.id, 3251 'name': self.name, 3252 'override_database': self.override_database, 3253 'password': self.password, 3254 'port': self.port, 3255 'port_override': self.port_override, 3256 'secret_store_id': self.secret_store_id, 3257 'tags': self.tags, 3258 'username': self.username, 3259 }
View Source
3261 @classmethod 3262 def from_dict(cls, d): 3263 return cls( 3264 database=d.get('database'), 3265 egress_filter=d.get('egress_filter'), 3266 healthy=d.get('healthy'), 3267 hostname=d.get('hostname'), 3268 id=d.get('id'), 3269 name=d.get('name'), 3270 override_database=d.get('override_database'), 3271 password=d.get('password'), 3272 port=d.get('port'), 3273 port_override=d.get('port_override'), 3274 secret_store_id=d.get('secret_store_id'), 3275 tags=d.get('tags'), 3276 username=d.get('username'), 3277 )
View Source
3280class Clustrix: 3281 ''' 3282 3283 ''' 3284 __slots__ = [ 3285 'database', 3286 'egress_filter', 3287 'healthy', 3288 'hostname', 3289 'id', 3290 'name', 3291 'password', 3292 'port', 3293 'port_override', 3294 'secret_store_id', 3295 'tags', 3296 'username', 3297 ] 3298 3299 def __init__( 3300 self, 3301 database=None, 3302 egress_filter=None, 3303 healthy=None, 3304 hostname=None, 3305 id=None, 3306 name=None, 3307 password=None, 3308 port=None, 3309 port_override=None, 3310 secret_store_id=None, 3311 tags=None, 3312 username=None, 3313 ): 3314 self.database = database if database is not None else '' 3315 ''' 3316 3317 ''' 3318 self.egress_filter = egress_filter if egress_filter is not None else '' 3319 ''' 3320 A filter applied to the routing logic to pin datasource to nodes. 3321 ''' 3322 self.healthy = healthy if healthy is not None else False 3323 ''' 3324 True if the datasource is reachable and the credentials are valid. 3325 ''' 3326 self.hostname = hostname if hostname is not None else '' 3327 ''' 3328 3329 ''' 3330 self.id = id if id is not None else '' 3331 ''' 3332 Unique identifier of the Resource. 3333 ''' 3334 self.name = name if name is not None else '' 3335 ''' 3336 Unique human-readable name of the Resource. 3337 ''' 3338 self.password = password if password is not None else '' 3339 ''' 3340 3341 ''' 3342 self.port = port if port is not None else 0 3343 ''' 3344 3345 ''' 3346 self.port_override = port_override if port_override is not None else 0 3347 ''' 3348 3349 ''' 3350 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 3351 ''' 3352 ID of the secret store containing credentials for this resource, if any. 3353 ''' 3354 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 3355 ''' 3356 Tags is a map of key, value pairs. 3357 ''' 3358 self.username = username if username is not None else '' 3359 ''' 3360 3361 ''' 3362 3363 def __repr__(self): 3364 return '<sdm.Clustrix ' + \ 3365 'database: ' + repr(self.database) + ' ' +\ 3366 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 3367 'healthy: ' + repr(self.healthy) + ' ' +\ 3368 'hostname: ' + repr(self.hostname) + ' ' +\ 3369 'id: ' + repr(self.id) + ' ' +\ 3370 'name: ' + repr(self.name) + ' ' +\ 3371 'password: ' + repr(self.password) + ' ' +\ 3372 'port: ' + repr(self.port) + ' ' +\ 3373 'port_override: ' + repr(self.port_override) + ' ' +\ 3374 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 3375 'tags: ' + repr(self.tags) + ' ' +\ 3376 'username: ' + repr(self.username) + ' ' +\ 3377 '>' 3378 3379 def to_dict(self): 3380 return { 3381 'database': self.database, 3382 'egress_filter': self.egress_filter, 3383 'healthy': self.healthy, 3384 'hostname': self.hostname, 3385 'id': self.id, 3386 'name': self.name, 3387 'password': self.password, 3388 'port': self.port, 3389 'port_override': self.port_override, 3390 'secret_store_id': self.secret_store_id, 3391 'tags': self.tags, 3392 'username': self.username, 3393 } 3394 3395 @classmethod 3396 def from_dict(cls, d): 3397 return cls( 3398 database=d.get('database'), 3399 egress_filter=d.get('egress_filter'), 3400 healthy=d.get('healthy'), 3401 hostname=d.get('hostname'), 3402 id=d.get('id'), 3403 name=d.get('name'), 3404 password=d.get('password'), 3405 port=d.get('port'), 3406 port_override=d.get('port_override'), 3407 secret_store_id=d.get('secret_store_id'), 3408 tags=d.get('tags'), 3409 username=d.get('username'), 3410 )
#
Clustrix(
database=None,
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
password=None,
port=None,
port_override=None,
secret_store_id=None,
tags=None,
username=None
)
View Source
3299 def __init__( 3300 self, 3301 database=None, 3302 egress_filter=None, 3303 healthy=None, 3304 hostname=None, 3305 id=None, 3306 name=None, 3307 password=None, 3308 port=None, 3309 port_override=None, 3310 secret_store_id=None, 3311 tags=None, 3312 username=None, 3313 ): 3314 self.database = database if database is not None else '' 3315 ''' 3316 3317 ''' 3318 self.egress_filter = egress_filter if egress_filter is not None else '' 3319 ''' 3320 A filter applied to the routing logic to pin datasource to nodes. 3321 ''' 3322 self.healthy = healthy if healthy is not None else False 3323 ''' 3324 True if the datasource is reachable and the credentials are valid. 3325 ''' 3326 self.hostname = hostname if hostname is not None else '' 3327 ''' 3328 3329 ''' 3330 self.id = id if id is not None else '' 3331 ''' 3332 Unique identifier of the Resource. 3333 ''' 3334 self.name = name if name is not None else '' 3335 ''' 3336 Unique human-readable name of the Resource. 3337 ''' 3338 self.password = password if password is not None else '' 3339 ''' 3340 3341 ''' 3342 self.port = port if port is not None else 0 3343 ''' 3344 3345 ''' 3346 self.port_override = port_override if port_override is not None else 0 3347 ''' 3348 3349 ''' 3350 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 3351 ''' 3352 ID of the secret store containing credentials for this resource, if any. 3353 ''' 3354 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 3355 ''' 3356 Tags is a map of key, value pairs. 3357 ''' 3358 self.username = username if username is not None else '' 3359 ''' 3360 3361 '''
#
database
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
password
#
port
#
port_override
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
username
View Source
3379 def to_dict(self): 3380 return { 3381 'database': self.database, 3382 'egress_filter': self.egress_filter, 3383 'healthy': self.healthy, 3384 'hostname': self.hostname, 3385 'id': self.id, 3386 'name': self.name, 3387 'password': self.password, 3388 'port': self.port, 3389 'port_override': self.port_override, 3390 'secret_store_id': self.secret_store_id, 3391 'tags': self.tags, 3392 'username': self.username, 3393 }
View Source
3395 @classmethod 3396 def from_dict(cls, d): 3397 return cls( 3398 database=d.get('database'), 3399 egress_filter=d.get('egress_filter'), 3400 healthy=d.get('healthy'), 3401 hostname=d.get('hostname'), 3402 id=d.get('id'), 3403 name=d.get('name'), 3404 password=d.get('password'), 3405 port=d.get('port'), 3406 port_override=d.get('port_override'), 3407 secret_store_id=d.get('secret_store_id'), 3408 tags=d.get('tags'), 3409 username=d.get('username'), 3410 )
View Source
3413class Cockroach: 3414 ''' 3415 3416 ''' 3417 __slots__ = [ 3418 'database', 3419 'egress_filter', 3420 'healthy', 3421 'hostname', 3422 'id', 3423 'name', 3424 'override_database', 3425 'password', 3426 'port', 3427 'port_override', 3428 'secret_store_id', 3429 'tags', 3430 'username', 3431 ] 3432 3433 def __init__( 3434 self, 3435 database=None, 3436 egress_filter=None, 3437 healthy=None, 3438 hostname=None, 3439 id=None, 3440 name=None, 3441 override_database=None, 3442 password=None, 3443 port=None, 3444 port_override=None, 3445 secret_store_id=None, 3446 tags=None, 3447 username=None, 3448 ): 3449 self.database = database if database is not None else '' 3450 ''' 3451 3452 ''' 3453 self.egress_filter = egress_filter if egress_filter is not None else '' 3454 ''' 3455 A filter applied to the routing logic to pin datasource to nodes. 3456 ''' 3457 self.healthy = healthy if healthy is not None else False 3458 ''' 3459 True if the datasource is reachable and the credentials are valid. 3460 ''' 3461 self.hostname = hostname if hostname is not None else '' 3462 ''' 3463 3464 ''' 3465 self.id = id if id is not None else '' 3466 ''' 3467 Unique identifier of the Resource. 3468 ''' 3469 self.name = name if name is not None else '' 3470 ''' 3471 Unique human-readable name of the Resource. 3472 ''' 3473 self.override_database = override_database if override_database is not None else False 3474 ''' 3475 3476 ''' 3477 self.password = password if password is not None else '' 3478 ''' 3479 3480 ''' 3481 self.port = port if port is not None else 0 3482 ''' 3483 3484 ''' 3485 self.port_override = port_override if port_override is not None else 0 3486 ''' 3487 3488 ''' 3489 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 3490 ''' 3491 ID of the secret store containing credentials for this resource, if any. 3492 ''' 3493 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 3494 ''' 3495 Tags is a map of key, value pairs. 3496 ''' 3497 self.username = username if username is not None else '' 3498 ''' 3499 3500 ''' 3501 3502 def __repr__(self): 3503 return '<sdm.Cockroach ' + \ 3504 'database: ' + repr(self.database) + ' ' +\ 3505 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 3506 'healthy: ' + repr(self.healthy) + ' ' +\ 3507 'hostname: ' + repr(self.hostname) + ' ' +\ 3508 'id: ' + repr(self.id) + ' ' +\ 3509 'name: ' + repr(self.name) + ' ' +\ 3510 'override_database: ' + repr(self.override_database) + ' ' +\ 3511 'password: ' + repr(self.password) + ' ' +\ 3512 'port: ' + repr(self.port) + ' ' +\ 3513 'port_override: ' + repr(self.port_override) + ' ' +\ 3514 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 3515 'tags: ' + repr(self.tags) + ' ' +\ 3516 'username: ' + repr(self.username) + ' ' +\ 3517 '>' 3518 3519 def to_dict(self): 3520 return { 3521 'database': self.database, 3522 'egress_filter': self.egress_filter, 3523 'healthy': self.healthy, 3524 'hostname': self.hostname, 3525 'id': self.id, 3526 'name': self.name, 3527 'override_database': self.override_database, 3528 'password': self.password, 3529 'port': self.port, 3530 'port_override': self.port_override, 3531 'secret_store_id': self.secret_store_id, 3532 'tags': self.tags, 3533 'username': self.username, 3534 } 3535 3536 @classmethod 3537 def from_dict(cls, d): 3538 return cls( 3539 database=d.get('database'), 3540 egress_filter=d.get('egress_filter'), 3541 healthy=d.get('healthy'), 3542 hostname=d.get('hostname'), 3543 id=d.get('id'), 3544 name=d.get('name'), 3545 override_database=d.get('override_database'), 3546 password=d.get('password'), 3547 port=d.get('port'), 3548 port_override=d.get('port_override'), 3549 secret_store_id=d.get('secret_store_id'), 3550 tags=d.get('tags'), 3551 username=d.get('username'), 3552 )
#
Cockroach(
database=None,
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
override_database=None,
password=None,
port=None,
port_override=None,
secret_store_id=None,
tags=None,
username=None
)
View Source
3433 def __init__( 3434 self, 3435 database=None, 3436 egress_filter=None, 3437 healthy=None, 3438 hostname=None, 3439 id=None, 3440 name=None, 3441 override_database=None, 3442 password=None, 3443 port=None, 3444 port_override=None, 3445 secret_store_id=None, 3446 tags=None, 3447 username=None, 3448 ): 3449 self.database = database if database is not None else '' 3450 ''' 3451 3452 ''' 3453 self.egress_filter = egress_filter if egress_filter is not None else '' 3454 ''' 3455 A filter applied to the routing logic to pin datasource to nodes. 3456 ''' 3457 self.healthy = healthy if healthy is not None else False 3458 ''' 3459 True if the datasource is reachable and the credentials are valid. 3460 ''' 3461 self.hostname = hostname if hostname is not None else '' 3462 ''' 3463 3464 ''' 3465 self.id = id if id is not None else '' 3466 ''' 3467 Unique identifier of the Resource. 3468 ''' 3469 self.name = name if name is not None else '' 3470 ''' 3471 Unique human-readable name of the Resource. 3472 ''' 3473 self.override_database = override_database if override_database is not None else False 3474 ''' 3475 3476 ''' 3477 self.password = password if password is not None else '' 3478 ''' 3479 3480 ''' 3481 self.port = port if port is not None else 0 3482 ''' 3483 3484 ''' 3485 self.port_override = port_override if port_override is not None else 0 3486 ''' 3487 3488 ''' 3489 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 3490 ''' 3491 ID of the secret store containing credentials for this resource, if any. 3492 ''' 3493 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 3494 ''' 3495 Tags is a map of key, value pairs. 3496 ''' 3497 self.username = username if username is not None else '' 3498 ''' 3499 3500 '''
#
database
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
override_database
#
password
#
port
#
port_override
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
username
View Source
3519 def to_dict(self): 3520 return { 3521 'database': self.database, 3522 'egress_filter': self.egress_filter, 3523 'healthy': self.healthy, 3524 'hostname': self.hostname, 3525 'id': self.id, 3526 'name': self.name, 3527 'override_database': self.override_database, 3528 'password': self.password, 3529 'port': self.port, 3530 'port_override': self.port_override, 3531 'secret_store_id': self.secret_store_id, 3532 'tags': self.tags, 3533 'username': self.username, 3534 }
View Source
3536 @classmethod 3537 def from_dict(cls, d): 3538 return cls( 3539 database=d.get('database'), 3540 egress_filter=d.get('egress_filter'), 3541 healthy=d.get('healthy'), 3542 hostname=d.get('hostname'), 3543 id=d.get('id'), 3544 name=d.get('name'), 3545 override_database=d.get('override_database'), 3546 password=d.get('password'), 3547 port=d.get('port'), 3548 port_override=d.get('port_override'), 3549 secret_store_id=d.get('secret_store_id'), 3550 tags=d.get('tags'), 3551 username=d.get('username'), 3552 )
View Source
3555class ControlPanelGetSSHCAPublicKeyResponse: 3556 ''' 3557 ControlPanelGetSSHCAPublicKeyResponse represents a request for an 3558 organization's SSH Certificate Authority public key. 3559 ''' 3560 __slots__ = [ 3561 'meta', 3562 'public_key', 3563 'rate_limit', 3564 ] 3565 3566 def __init__( 3567 self, 3568 meta=None, 3569 public_key=None, 3570 rate_limit=None, 3571 ): 3572 self.meta = meta if meta is not None else None 3573 ''' 3574 Reserved for future use. 3575 ''' 3576 self.public_key = public_key if public_key is not None else '' 3577 ''' 3578 The public key of the SSH Certificate Authority, in OpenSSH RSA public 3579 key format. 3580 ''' 3581 self.rate_limit = rate_limit if rate_limit is not None else None 3582 ''' 3583 Rate limit information. 3584 ''' 3585 3586 def __repr__(self): 3587 return '<sdm.ControlPanelGetSSHCAPublicKeyResponse ' + \ 3588 'meta: ' + repr(self.meta) + ' ' +\ 3589 'public_key: ' + repr(self.public_key) + ' ' +\ 3590 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 3591 '>' 3592 3593 def to_dict(self): 3594 return { 3595 'meta': self.meta, 3596 'public_key': self.public_key, 3597 'rate_limit': self.rate_limit, 3598 } 3599 3600 @classmethod 3601 def from_dict(cls, d): 3602 return cls( 3603 meta=d.get('meta'), 3604 public_key=d.get('public_key'), 3605 rate_limit=d.get('rate_limit'), 3606 )
ControlPanelGetSSHCAPublicKeyResponse represents a request for an organization's SSH Certificate Authority public key.
View Source
3566 def __init__( 3567 self, 3568 meta=None, 3569 public_key=None, 3570 rate_limit=None, 3571 ): 3572 self.meta = meta if meta is not None else None 3573 ''' 3574 Reserved for future use. 3575 ''' 3576 self.public_key = public_key if public_key is not None else '' 3577 ''' 3578 The public key of the SSH Certificate Authority, in OpenSSH RSA public 3579 key format. 3580 ''' 3581 self.rate_limit = rate_limit if rate_limit is not None else None 3582 ''' 3583 Rate limit information. 3584 '''
#
meta
Reserved for future use.
#
public_key
The public key of the SSH Certificate Authority, in OpenSSH RSA public key format.
#
rate_limit
Rate limit information.
View Source
3609class ControlPanelVerifyJWTResponse: 3610 ''' 3611 ControlPanelVerifyJWTResponse reports whether x-sdm-token is valid. 3612 ''' 3613 __slots__ = [ 3614 'meta', 3615 'rate_limit', 3616 'valid', 3617 ] 3618 3619 def __init__( 3620 self, 3621 meta=None, 3622 rate_limit=None, 3623 valid=None, 3624 ): 3625 self.meta = meta if meta is not None else None 3626 ''' 3627 Reserved for future use. 3628 ''' 3629 self.rate_limit = rate_limit if rate_limit is not None else None 3630 ''' 3631 Rate limit information. 3632 ''' 3633 self.valid = valid if valid is not None else False 3634 ''' 3635 Reports if the given token is valid. 3636 ''' 3637 3638 def __repr__(self): 3639 return '<sdm.ControlPanelVerifyJWTResponse ' + \ 3640 'meta: ' + repr(self.meta) + ' ' +\ 3641 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 3642 'valid: ' + repr(self.valid) + ' ' +\ 3643 '>' 3644 3645 def to_dict(self): 3646 return { 3647 'meta': self.meta, 3648 'rate_limit': self.rate_limit, 3649 'valid': self.valid, 3650 } 3651 3652 @classmethod 3653 def from_dict(cls, d): 3654 return cls( 3655 meta=d.get('meta'), 3656 rate_limit=d.get('rate_limit'), 3657 valid=d.get('valid'), 3658 )
ControlPanelVerifyJWTResponse reports whether x-sdm-token is valid.
View Source
3619 def __init__( 3620 self, 3621 meta=None, 3622 rate_limit=None, 3623 valid=None, 3624 ): 3625 self.meta = meta if meta is not None else None 3626 ''' 3627 Reserved for future use. 3628 ''' 3629 self.rate_limit = rate_limit if rate_limit is not None else None 3630 ''' 3631 Rate limit information. 3632 ''' 3633 self.valid = valid if valid is not None else False 3634 ''' 3635 Reports if the given token is valid. 3636 '''
#
meta
Reserved for future use.
#
rate_limit
Rate limit information.
#
valid
Reports if the given token is valid.
View Source
3661class CreateResponseMetadata: 3662 ''' 3663 CreateResponseMetadata is reserved for future use. 3664 ''' 3665 __slots__ = [] 3666 3667 def __init__(self, ): 3668 pass 3669 3670 def __repr__(self): 3671 return '<sdm.CreateResponseMetadata ' + \ 3672 '>' 3673 3674 def to_dict(self): 3675 return {} 3676 3677 @classmethod 3678 def from_dict(cls, d): 3679 return cls()
CreateResponseMetadata is reserved for future use.
View Source
3682class DB2I: 3683 ''' 3684 3685 ''' 3686 __slots__ = [ 3687 'egress_filter', 3688 'healthy', 3689 'hostname', 3690 'id', 3691 'name', 3692 'password', 3693 'port', 3694 'port_override', 3695 'secret_store_id', 3696 'tags', 3697 'tls_required', 3698 'username', 3699 ] 3700 3701 def __init__( 3702 self, 3703 egress_filter=None, 3704 healthy=None, 3705 hostname=None, 3706 id=None, 3707 name=None, 3708 password=None, 3709 port=None, 3710 port_override=None, 3711 secret_store_id=None, 3712 tags=None, 3713 tls_required=None, 3714 username=None, 3715 ): 3716 self.egress_filter = egress_filter if egress_filter is not None else '' 3717 ''' 3718 A filter applied to the routing logic to pin datasource to nodes. 3719 ''' 3720 self.healthy = healthy if healthy is not None else False 3721 ''' 3722 True if the datasource is reachable and the credentials are valid. 3723 ''' 3724 self.hostname = hostname if hostname is not None else '' 3725 ''' 3726 3727 ''' 3728 self.id = id if id is not None else '' 3729 ''' 3730 Unique identifier of the Resource. 3731 ''' 3732 self.name = name if name is not None else '' 3733 ''' 3734 Unique human-readable name of the Resource. 3735 ''' 3736 self.password = password if password is not None else '' 3737 ''' 3738 3739 ''' 3740 self.port = port if port is not None else 0 3741 ''' 3742 3743 ''' 3744 self.port_override = port_override if port_override is not None else 0 3745 ''' 3746 3747 ''' 3748 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 3749 ''' 3750 ID of the secret store containing credentials for this resource, if any. 3751 ''' 3752 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 3753 ''' 3754 Tags is a map of key, value pairs. 3755 ''' 3756 self.tls_required = tls_required if tls_required is not None else False 3757 ''' 3758 3759 ''' 3760 self.username = username if username is not None else '' 3761 ''' 3762 3763 ''' 3764 3765 def __repr__(self): 3766 return '<sdm.DB2I ' + \ 3767 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 3768 'healthy: ' + repr(self.healthy) + ' ' +\ 3769 'hostname: ' + repr(self.hostname) + ' ' +\ 3770 'id: ' + repr(self.id) + ' ' +\ 3771 'name: ' + repr(self.name) + ' ' +\ 3772 'password: ' + repr(self.password) + ' ' +\ 3773 'port: ' + repr(self.port) + ' ' +\ 3774 'port_override: ' + repr(self.port_override) + ' ' +\ 3775 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 3776 'tags: ' + repr(self.tags) + ' ' +\ 3777 'tls_required: ' + repr(self.tls_required) + ' ' +\ 3778 'username: ' + repr(self.username) + ' ' +\ 3779 '>' 3780 3781 def to_dict(self): 3782 return { 3783 'egress_filter': self.egress_filter, 3784 'healthy': self.healthy, 3785 'hostname': self.hostname, 3786 'id': self.id, 3787 'name': self.name, 3788 'password': self.password, 3789 'port': self.port, 3790 'port_override': self.port_override, 3791 'secret_store_id': self.secret_store_id, 3792 'tags': self.tags, 3793 'tls_required': self.tls_required, 3794 'username': self.username, 3795 } 3796 3797 @classmethod 3798 def from_dict(cls, d): 3799 return cls( 3800 egress_filter=d.get('egress_filter'), 3801 healthy=d.get('healthy'), 3802 hostname=d.get('hostname'), 3803 id=d.get('id'), 3804 name=d.get('name'), 3805 password=d.get('password'), 3806 port=d.get('port'), 3807 port_override=d.get('port_override'), 3808 secret_store_id=d.get('secret_store_id'), 3809 tags=d.get('tags'), 3810 tls_required=d.get('tls_required'), 3811 username=d.get('username'), 3812 )
#
DB2I(
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
password=None,
port=None,
port_override=None,
secret_store_id=None,
tags=None,
tls_required=None,
username=None
)
View Source
3701 def __init__( 3702 self, 3703 egress_filter=None, 3704 healthy=None, 3705 hostname=None, 3706 id=None, 3707 name=None, 3708 password=None, 3709 port=None, 3710 port_override=None, 3711 secret_store_id=None, 3712 tags=None, 3713 tls_required=None, 3714 username=None, 3715 ): 3716 self.egress_filter = egress_filter if egress_filter is not None else '' 3717 ''' 3718 A filter applied to the routing logic to pin datasource to nodes. 3719 ''' 3720 self.healthy = healthy if healthy is not None else False 3721 ''' 3722 True if the datasource is reachable and the credentials are valid. 3723 ''' 3724 self.hostname = hostname if hostname is not None else '' 3725 ''' 3726 3727 ''' 3728 self.id = id if id is not None else '' 3729 ''' 3730 Unique identifier of the Resource. 3731 ''' 3732 self.name = name if name is not None else '' 3733 ''' 3734 Unique human-readable name of the Resource. 3735 ''' 3736 self.password = password if password is not None else '' 3737 ''' 3738 3739 ''' 3740 self.port = port if port is not None else 0 3741 ''' 3742 3743 ''' 3744 self.port_override = port_override if port_override is not None else 0 3745 ''' 3746 3747 ''' 3748 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 3749 ''' 3750 ID of the secret store containing credentials for this resource, if any. 3751 ''' 3752 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 3753 ''' 3754 Tags is a map of key, value pairs. 3755 ''' 3756 self.tls_required = tls_required if tls_required is not None else False 3757 ''' 3758 3759 ''' 3760 self.username = username if username is not None else '' 3761 ''' 3762 3763 '''
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
password
#
port
#
port_override
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
tls_required
#
username
View Source
3781 def to_dict(self): 3782 return { 3783 'egress_filter': self.egress_filter, 3784 'healthy': self.healthy, 3785 'hostname': self.hostname, 3786 'id': self.id, 3787 'name': self.name, 3788 'password': self.password, 3789 'port': self.port, 3790 'port_override': self.port_override, 3791 'secret_store_id': self.secret_store_id, 3792 'tags': self.tags, 3793 'tls_required': self.tls_required, 3794 'username': self.username, 3795 }
View Source
3797 @classmethod 3798 def from_dict(cls, d): 3799 return cls( 3800 egress_filter=d.get('egress_filter'), 3801 healthy=d.get('healthy'), 3802 hostname=d.get('hostname'), 3803 id=d.get('id'), 3804 name=d.get('name'), 3805 password=d.get('password'), 3806 port=d.get('port'), 3807 port_override=d.get('port_override'), 3808 secret_store_id=d.get('secret_store_id'), 3809 tags=d.get('tags'), 3810 tls_required=d.get('tls_required'), 3811 username=d.get('username'), 3812 )
View Source
3815class DB2LUW: 3816 ''' 3817 3818 ''' 3819 __slots__ = [ 3820 'database', 3821 'egress_filter', 3822 'healthy', 3823 'hostname', 3824 'id', 3825 'name', 3826 'password', 3827 'port', 3828 'port_override', 3829 'secret_store_id', 3830 'tags', 3831 'username', 3832 ] 3833 3834 def __init__( 3835 self, 3836 database=None, 3837 egress_filter=None, 3838 healthy=None, 3839 hostname=None, 3840 id=None, 3841 name=None, 3842 password=None, 3843 port=None, 3844 port_override=None, 3845 secret_store_id=None, 3846 tags=None, 3847 username=None, 3848 ): 3849 self.database = database if database is not None else '' 3850 ''' 3851 3852 ''' 3853 self.egress_filter = egress_filter if egress_filter is not None else '' 3854 ''' 3855 A filter applied to the routing logic to pin datasource to nodes. 3856 ''' 3857 self.healthy = healthy if healthy is not None else False 3858 ''' 3859 True if the datasource is reachable and the credentials are valid. 3860 ''' 3861 self.hostname = hostname if hostname is not None else '' 3862 ''' 3863 3864 ''' 3865 self.id = id if id is not None else '' 3866 ''' 3867 Unique identifier of the Resource. 3868 ''' 3869 self.name = name if name is not None else '' 3870 ''' 3871 Unique human-readable name of the Resource. 3872 ''' 3873 self.password = password if password is not None else '' 3874 ''' 3875 3876 ''' 3877 self.port = port if port is not None else 0 3878 ''' 3879 3880 ''' 3881 self.port_override = port_override if port_override is not None else 0 3882 ''' 3883 3884 ''' 3885 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 3886 ''' 3887 ID of the secret store containing credentials for this resource, if any. 3888 ''' 3889 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 3890 ''' 3891 Tags is a map of key, value pairs. 3892 ''' 3893 self.username = username if username is not None else '' 3894 ''' 3895 3896 ''' 3897 3898 def __repr__(self): 3899 return '<sdm.DB2LUW ' + \ 3900 'database: ' + repr(self.database) + ' ' +\ 3901 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 3902 'healthy: ' + repr(self.healthy) + ' ' +\ 3903 'hostname: ' + repr(self.hostname) + ' ' +\ 3904 'id: ' + repr(self.id) + ' ' +\ 3905 'name: ' + repr(self.name) + ' ' +\ 3906 'password: ' + repr(self.password) + ' ' +\ 3907 'port: ' + repr(self.port) + ' ' +\ 3908 'port_override: ' + repr(self.port_override) + ' ' +\ 3909 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 3910 'tags: ' + repr(self.tags) + ' ' +\ 3911 'username: ' + repr(self.username) + ' ' +\ 3912 '>' 3913 3914 def to_dict(self): 3915 return { 3916 'database': self.database, 3917 'egress_filter': self.egress_filter, 3918 'healthy': self.healthy, 3919 'hostname': self.hostname, 3920 'id': self.id, 3921 'name': self.name, 3922 'password': self.password, 3923 'port': self.port, 3924 'port_override': self.port_override, 3925 'secret_store_id': self.secret_store_id, 3926 'tags': self.tags, 3927 'username': self.username, 3928 } 3929 3930 @classmethod 3931 def from_dict(cls, d): 3932 return cls( 3933 database=d.get('database'), 3934 egress_filter=d.get('egress_filter'), 3935 healthy=d.get('healthy'), 3936 hostname=d.get('hostname'), 3937 id=d.get('id'), 3938 name=d.get('name'), 3939 password=d.get('password'), 3940 port=d.get('port'), 3941 port_override=d.get('port_override'), 3942 secret_store_id=d.get('secret_store_id'), 3943 tags=d.get('tags'), 3944 username=d.get('username'), 3945 )
#
DB2LUW(
database=None,
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
password=None,
port=None,
port_override=None,
secret_store_id=None,
tags=None,
username=None
)
View Source
3834 def __init__( 3835 self, 3836 database=None, 3837 egress_filter=None, 3838 healthy=None, 3839 hostname=None, 3840 id=None, 3841 name=None, 3842 password=None, 3843 port=None, 3844 port_override=None, 3845 secret_store_id=None, 3846 tags=None, 3847 username=None, 3848 ): 3849 self.database = database if database is not None else '' 3850 ''' 3851 3852 ''' 3853 self.egress_filter = egress_filter if egress_filter is not None else '' 3854 ''' 3855 A filter applied to the routing logic to pin datasource to nodes. 3856 ''' 3857 self.healthy = healthy if healthy is not None else False 3858 ''' 3859 True if the datasource is reachable and the credentials are valid. 3860 ''' 3861 self.hostname = hostname if hostname is not None else '' 3862 ''' 3863 3864 ''' 3865 self.id = id if id is not None else '' 3866 ''' 3867 Unique identifier of the Resource. 3868 ''' 3869 self.name = name if name is not None else '' 3870 ''' 3871 Unique human-readable name of the Resource. 3872 ''' 3873 self.password = password if password is not None else '' 3874 ''' 3875 3876 ''' 3877 self.port = port if port is not None else 0 3878 ''' 3879 3880 ''' 3881 self.port_override = port_override if port_override is not None else 0 3882 ''' 3883 3884 ''' 3885 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 3886 ''' 3887 ID of the secret store containing credentials for this resource, if any. 3888 ''' 3889 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 3890 ''' 3891 Tags is a map of key, value pairs. 3892 ''' 3893 self.username = username if username is not None else '' 3894 ''' 3895 3896 '''
#
database
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
password
#
port
#
port_override
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
username
View Source
3914 def to_dict(self): 3915 return { 3916 'database': self.database, 3917 'egress_filter': self.egress_filter, 3918 'healthy': self.healthy, 3919 'hostname': self.hostname, 3920 'id': self.id, 3921 'name': self.name, 3922 'password': self.password, 3923 'port': self.port, 3924 'port_override': self.port_override, 3925 'secret_store_id': self.secret_store_id, 3926 'tags': self.tags, 3927 'username': self.username, 3928 }
View Source
3930 @classmethod 3931 def from_dict(cls, d): 3932 return cls( 3933 database=d.get('database'), 3934 egress_filter=d.get('egress_filter'), 3935 healthy=d.get('healthy'), 3936 hostname=d.get('hostname'), 3937 id=d.get('id'), 3938 name=d.get('name'), 3939 password=d.get('password'), 3940 port=d.get('port'), 3941 port_override=d.get('port_override'), 3942 secret_store_id=d.get('secret_store_id'), 3943 tags=d.get('tags'), 3944 username=d.get('username'), 3945 )
View Source
3948class DeleteResponseMetadata: 3949 ''' 3950 DeleteResponseMetadata is reserved for future use. 3951 ''' 3952 __slots__ = [] 3953 3954 def __init__(self, ): 3955 pass 3956 3957 def __repr__(self): 3958 return '<sdm.DeleteResponseMetadata ' + \ 3959 '>' 3960 3961 def to_dict(self): 3962 return {} 3963 3964 @classmethod 3965 def from_dict(cls, d): 3966 return cls()
DeleteResponseMetadata is reserved for future use.
View Source
3969class DocumentDBHost: 3970 ''' 3971 3972 ''' 3973 __slots__ = [ 3974 'auth_database', 3975 'egress_filter', 3976 'healthy', 3977 'hostname', 3978 'id', 3979 'name', 3980 'password', 3981 'port', 3982 'port_override', 3983 'secret_store_id', 3984 'tags', 3985 'username', 3986 ] 3987 3988 def __init__( 3989 self, 3990 auth_database=None, 3991 egress_filter=None, 3992 healthy=None, 3993 hostname=None, 3994 id=None, 3995 name=None, 3996 password=None, 3997 port=None, 3998 port_override=None, 3999 secret_store_id=None, 4000 tags=None, 4001 username=None, 4002 ): 4003 self.auth_database = auth_database if auth_database is not None else '' 4004 ''' 4005 4006 ''' 4007 self.egress_filter = egress_filter if egress_filter is not None else '' 4008 ''' 4009 A filter applied to the routing logic to pin datasource to nodes. 4010 ''' 4011 self.healthy = healthy if healthy is not None else False 4012 ''' 4013 True if the datasource is reachable and the credentials are valid. 4014 ''' 4015 self.hostname = hostname if hostname is not None else '' 4016 ''' 4017 4018 ''' 4019 self.id = id if id is not None else '' 4020 ''' 4021 Unique identifier of the Resource. 4022 ''' 4023 self.name = name if name is not None else '' 4024 ''' 4025 Unique human-readable name of the Resource. 4026 ''' 4027 self.password = password if password is not None else '' 4028 ''' 4029 4030 ''' 4031 self.port = port if port is not None else 0 4032 ''' 4033 4034 ''' 4035 self.port_override = port_override if port_override is not None else 0 4036 ''' 4037 4038 ''' 4039 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 4040 ''' 4041 ID of the secret store containing credentials for this resource, if any. 4042 ''' 4043 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 4044 ''' 4045 Tags is a map of key, value pairs. 4046 ''' 4047 self.username = username if username is not None else '' 4048 ''' 4049 4050 ''' 4051 4052 def __repr__(self): 4053 return '<sdm.DocumentDBHost ' + \ 4054 'auth_database: ' + repr(self.auth_database) + ' ' +\ 4055 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 4056 'healthy: ' + repr(self.healthy) + ' ' +\ 4057 'hostname: ' + repr(self.hostname) + ' ' +\ 4058 'id: ' + repr(self.id) + ' ' +\ 4059 'name: ' + repr(self.name) + ' ' +\ 4060 'password: ' + repr(self.password) + ' ' +\ 4061 'port: ' + repr(self.port) + ' ' +\ 4062 'port_override: ' + repr(self.port_override) + ' ' +\ 4063 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 4064 'tags: ' + repr(self.tags) + ' ' +\ 4065 'username: ' + repr(self.username) + ' ' +\ 4066 '>' 4067 4068 def to_dict(self): 4069 return { 4070 'auth_database': self.auth_database, 4071 'egress_filter': self.egress_filter, 4072 'healthy': self.healthy, 4073 'hostname': self.hostname, 4074 'id': self.id, 4075 'name': self.name, 4076 'password': self.password, 4077 'port': self.port, 4078 'port_override': self.port_override, 4079 'secret_store_id': self.secret_store_id, 4080 'tags': self.tags, 4081 'username': self.username, 4082 } 4083 4084 @classmethod 4085 def from_dict(cls, d): 4086 return cls( 4087 auth_database=d.get('auth_database'), 4088 egress_filter=d.get('egress_filter'), 4089 healthy=d.get('healthy'), 4090 hostname=d.get('hostname'), 4091 id=d.get('id'), 4092 name=d.get('name'), 4093 password=d.get('password'), 4094 port=d.get('port'), 4095 port_override=d.get('port_override'), 4096 secret_store_id=d.get('secret_store_id'), 4097 tags=d.get('tags'), 4098 username=d.get('username'), 4099 )
#
DocumentDBHost(
auth_database=None,
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
password=None,
port=None,
port_override=None,
secret_store_id=None,
tags=None,
username=None
)
View Source
3988 def __init__( 3989 self, 3990 auth_database=None, 3991 egress_filter=None, 3992 healthy=None, 3993 hostname=None, 3994 id=None, 3995 name=None, 3996 password=None, 3997 port=None, 3998 port_override=None, 3999 secret_store_id=None, 4000 tags=None, 4001 username=None, 4002 ): 4003 self.auth_database = auth_database if auth_database is not None else '' 4004 ''' 4005 4006 ''' 4007 self.egress_filter = egress_filter if egress_filter is not None else '' 4008 ''' 4009 A filter applied to the routing logic to pin datasource to nodes. 4010 ''' 4011 self.healthy = healthy if healthy is not None else False 4012 ''' 4013 True if the datasource is reachable and the credentials are valid. 4014 ''' 4015 self.hostname = hostname if hostname is not None else '' 4016 ''' 4017 4018 ''' 4019 self.id = id if id is not None else '' 4020 ''' 4021 Unique identifier of the Resource. 4022 ''' 4023 self.name = name if name is not None else '' 4024 ''' 4025 Unique human-readable name of the Resource. 4026 ''' 4027 self.password = password if password is not None else '' 4028 ''' 4029 4030 ''' 4031 self.port = port if port is not None else 0 4032 ''' 4033 4034 ''' 4035 self.port_override = port_override if port_override is not None else 0 4036 ''' 4037 4038 ''' 4039 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 4040 ''' 4041 ID of the secret store containing credentials for this resource, if any. 4042 ''' 4043 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 4044 ''' 4045 Tags is a map of key, value pairs. 4046 ''' 4047 self.username = username if username is not None else '' 4048 ''' 4049 4050 '''
#
auth_database
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
password
#
port
#
port_override
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
username
View Source
4068 def to_dict(self): 4069 return { 4070 'auth_database': self.auth_database, 4071 'egress_filter': self.egress_filter, 4072 'healthy': self.healthy, 4073 'hostname': self.hostname, 4074 'id': self.id, 4075 'name': self.name, 4076 'password': self.password, 4077 'port': self.port, 4078 'port_override': self.port_override, 4079 'secret_store_id': self.secret_store_id, 4080 'tags': self.tags, 4081 'username': self.username, 4082 }
View Source
4084 @classmethod 4085 def from_dict(cls, d): 4086 return cls( 4087 auth_database=d.get('auth_database'), 4088 egress_filter=d.get('egress_filter'), 4089 healthy=d.get('healthy'), 4090 hostname=d.get('hostname'), 4091 id=d.get('id'), 4092 name=d.get('name'), 4093 password=d.get('password'), 4094 port=d.get('port'), 4095 port_override=d.get('port_override'), 4096 secret_store_id=d.get('secret_store_id'), 4097 tags=d.get('tags'), 4098 username=d.get('username'), 4099 )
View Source
4102class DocumentDBReplicaSet: 4103 ''' 4104 4105 ''' 4106 __slots__ = [ 4107 'auth_database', 4108 'connect_to_replica', 4109 'egress_filter', 4110 'healthy', 4111 'hostname', 4112 'id', 4113 'name', 4114 'password', 4115 'port_override', 4116 'replica_set', 4117 'secret_store_id', 4118 'tags', 4119 'username', 4120 ] 4121 4122 def __init__( 4123 self, 4124 auth_database=None, 4125 connect_to_replica=None, 4126 egress_filter=None, 4127 healthy=None, 4128 hostname=None, 4129 id=None, 4130 name=None, 4131 password=None, 4132 port_override=None, 4133 replica_set=None, 4134 secret_store_id=None, 4135 tags=None, 4136 username=None, 4137 ): 4138 self.auth_database = auth_database if auth_database is not None else '' 4139 ''' 4140 4141 ''' 4142 self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False 4143 ''' 4144 4145 ''' 4146 self.egress_filter = egress_filter if egress_filter is not None else '' 4147 ''' 4148 A filter applied to the routing logic to pin datasource to nodes. 4149 ''' 4150 self.healthy = healthy if healthy is not None else False 4151 ''' 4152 True if the datasource is reachable and the credentials are valid. 4153 ''' 4154 self.hostname = hostname if hostname is not None else '' 4155 ''' 4156 Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas. 4157 ''' 4158 self.id = id if id is not None else '' 4159 ''' 4160 Unique identifier of the Resource. 4161 ''' 4162 self.name = name if name is not None else '' 4163 ''' 4164 Unique human-readable name of the Resource. 4165 ''' 4166 self.password = password if password is not None else '' 4167 ''' 4168 4169 ''' 4170 self.port_override = port_override if port_override is not None else 0 4171 ''' 4172 4173 ''' 4174 self.replica_set = replica_set if replica_set is not None else '' 4175 ''' 4176 4177 ''' 4178 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 4179 ''' 4180 ID of the secret store containing credentials for this resource, if any. 4181 ''' 4182 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 4183 ''' 4184 Tags is a map of key, value pairs. 4185 ''' 4186 self.username = username if username is not None else '' 4187 ''' 4188 4189 ''' 4190 4191 def __repr__(self): 4192 return '<sdm.DocumentDBReplicaSet ' + \ 4193 'auth_database: ' + repr(self.auth_database) + ' ' +\ 4194 'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\ 4195 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 4196 'healthy: ' + repr(self.healthy) + ' ' +\ 4197 'hostname: ' + repr(self.hostname) + ' ' +\ 4198 'id: ' + repr(self.id) + ' ' +\ 4199 'name: ' + repr(self.name) + ' ' +\ 4200 'password: ' + repr(self.password) + ' ' +\ 4201 'port_override: ' + repr(self.port_override) + ' ' +\ 4202 'replica_set: ' + repr(self.replica_set) + ' ' +\ 4203 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 4204 'tags: ' + repr(self.tags) + ' ' +\ 4205 'username: ' + repr(self.username) + ' ' +\ 4206 '>' 4207 4208 def to_dict(self): 4209 return { 4210 'auth_database': self.auth_database, 4211 'connect_to_replica': self.connect_to_replica, 4212 'egress_filter': self.egress_filter, 4213 'healthy': self.healthy, 4214 'hostname': self.hostname, 4215 'id': self.id, 4216 'name': self.name, 4217 'password': self.password, 4218 'port_override': self.port_override, 4219 'replica_set': self.replica_set, 4220 'secret_store_id': self.secret_store_id, 4221 'tags': self.tags, 4222 'username': self.username, 4223 } 4224 4225 @classmethod 4226 def from_dict(cls, d): 4227 return cls( 4228 auth_database=d.get('auth_database'), 4229 connect_to_replica=d.get('connect_to_replica'), 4230 egress_filter=d.get('egress_filter'), 4231 healthy=d.get('healthy'), 4232 hostname=d.get('hostname'), 4233 id=d.get('id'), 4234 name=d.get('name'), 4235 password=d.get('password'), 4236 port_override=d.get('port_override'), 4237 replica_set=d.get('replica_set'), 4238 secret_store_id=d.get('secret_store_id'), 4239 tags=d.get('tags'), 4240 username=d.get('username'), 4241 )
#
DocumentDBReplicaSet(
auth_database=None,
connect_to_replica=None,
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
password=None,
port_override=None,
replica_set=None,
secret_store_id=None,
tags=None,
username=None
)
View Source
4122 def __init__( 4123 self, 4124 auth_database=None, 4125 connect_to_replica=None, 4126 egress_filter=None, 4127 healthy=None, 4128 hostname=None, 4129 id=None, 4130 name=None, 4131 password=None, 4132 port_override=None, 4133 replica_set=None, 4134 secret_store_id=None, 4135 tags=None, 4136 username=None, 4137 ): 4138 self.auth_database = auth_database if auth_database is not None else '' 4139 ''' 4140 4141 ''' 4142 self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False 4143 ''' 4144 4145 ''' 4146 self.egress_filter = egress_filter if egress_filter is not None else '' 4147 ''' 4148 A filter applied to the routing logic to pin datasource to nodes. 4149 ''' 4150 self.healthy = healthy if healthy is not None else False 4151 ''' 4152 True if the datasource is reachable and the credentials are valid. 4153 ''' 4154 self.hostname = hostname if hostname is not None else '' 4155 ''' 4156 Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas. 4157 ''' 4158 self.id = id if id is not None else '' 4159 ''' 4160 Unique identifier of the Resource. 4161 ''' 4162 self.name = name if name is not None else '' 4163 ''' 4164 Unique human-readable name of the Resource. 4165 ''' 4166 self.password = password if password is not None else '' 4167 ''' 4168 4169 ''' 4170 self.port_override = port_override if port_override is not None else 0 4171 ''' 4172 4173 ''' 4174 self.replica_set = replica_set if replica_set is not None else '' 4175 ''' 4176 4177 ''' 4178 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 4179 ''' 4180 ID of the secret store containing credentials for this resource, if any. 4181 ''' 4182 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 4183 ''' 4184 Tags is a map of key, value pairs. 4185 ''' 4186 self.username = username if username is not None else '' 4187 ''' 4188 4189 '''
#
auth_database
#
connect_to_replica
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
password
#
port_override
#
replica_set
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
username
View Source
4208 def to_dict(self): 4209 return { 4210 'auth_database': self.auth_database, 4211 'connect_to_replica': self.connect_to_replica, 4212 'egress_filter': self.egress_filter, 4213 'healthy': self.healthy, 4214 'hostname': self.hostname, 4215 'id': self.id, 4216 'name': self.name, 4217 'password': self.password, 4218 'port_override': self.port_override, 4219 'replica_set': self.replica_set, 4220 'secret_store_id': self.secret_store_id, 4221 'tags': self.tags, 4222 'username': self.username, 4223 }
View Source
4225 @classmethod 4226 def from_dict(cls, d): 4227 return cls( 4228 auth_database=d.get('auth_database'), 4229 connect_to_replica=d.get('connect_to_replica'), 4230 egress_filter=d.get('egress_filter'), 4231 healthy=d.get('healthy'), 4232 hostname=d.get('hostname'), 4233 id=d.get('id'), 4234 name=d.get('name'), 4235 password=d.get('password'), 4236 port_override=d.get('port_override'), 4237 replica_set=d.get('replica_set'), 4238 secret_store_id=d.get('secret_store_id'), 4239 tags=d.get('tags'), 4240 username=d.get('username'), 4241 )
View Source
4244class Druid: 4245 ''' 4246 4247 ''' 4248 __slots__ = [ 4249 'egress_filter', 4250 'healthy', 4251 'hostname', 4252 'id', 4253 'name', 4254 'password', 4255 'port', 4256 'port_override', 4257 'secret_store_id', 4258 'tags', 4259 'username', 4260 ] 4261 4262 def __init__( 4263 self, 4264 egress_filter=None, 4265 healthy=None, 4266 hostname=None, 4267 id=None, 4268 name=None, 4269 password=None, 4270 port=None, 4271 port_override=None, 4272 secret_store_id=None, 4273 tags=None, 4274 username=None, 4275 ): 4276 self.egress_filter = egress_filter if egress_filter is not None else '' 4277 ''' 4278 A filter applied to the routing logic to pin datasource to nodes. 4279 ''' 4280 self.healthy = healthy if healthy is not None else False 4281 ''' 4282 True if the datasource is reachable and the credentials are valid. 4283 ''' 4284 self.hostname = hostname if hostname is not None else '' 4285 ''' 4286 4287 ''' 4288 self.id = id if id is not None else '' 4289 ''' 4290 Unique identifier of the Resource. 4291 ''' 4292 self.name = name if name is not None else '' 4293 ''' 4294 Unique human-readable name of the Resource. 4295 ''' 4296 self.password = password if password is not None else '' 4297 ''' 4298 4299 ''' 4300 self.port = port if port is not None else 0 4301 ''' 4302 4303 ''' 4304 self.port_override = port_override if port_override is not None else 0 4305 ''' 4306 4307 ''' 4308 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 4309 ''' 4310 ID of the secret store containing credentials for this resource, if any. 4311 ''' 4312 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 4313 ''' 4314 Tags is a map of key, value pairs. 4315 ''' 4316 self.username = username if username is not None else '' 4317 ''' 4318 4319 ''' 4320 4321 def __repr__(self): 4322 return '<sdm.Druid ' + \ 4323 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 4324 'healthy: ' + repr(self.healthy) + ' ' +\ 4325 'hostname: ' + repr(self.hostname) + ' ' +\ 4326 'id: ' + repr(self.id) + ' ' +\ 4327 'name: ' + repr(self.name) + ' ' +\ 4328 'password: ' + repr(self.password) + ' ' +\ 4329 'port: ' + repr(self.port) + ' ' +\ 4330 'port_override: ' + repr(self.port_override) + ' ' +\ 4331 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 4332 'tags: ' + repr(self.tags) + ' ' +\ 4333 'username: ' + repr(self.username) + ' ' +\ 4334 '>' 4335 4336 def to_dict(self): 4337 return { 4338 'egress_filter': self.egress_filter, 4339 'healthy': self.healthy, 4340 'hostname': self.hostname, 4341 'id': self.id, 4342 'name': self.name, 4343 'password': self.password, 4344 'port': self.port, 4345 'port_override': self.port_override, 4346 'secret_store_id': self.secret_store_id, 4347 'tags': self.tags, 4348 'username': self.username, 4349 } 4350 4351 @classmethod 4352 def from_dict(cls, d): 4353 return cls( 4354 egress_filter=d.get('egress_filter'), 4355 healthy=d.get('healthy'), 4356 hostname=d.get('hostname'), 4357 id=d.get('id'), 4358 name=d.get('name'), 4359 password=d.get('password'), 4360 port=d.get('port'), 4361 port_override=d.get('port_override'), 4362 secret_store_id=d.get('secret_store_id'), 4363 tags=d.get('tags'), 4364 username=d.get('username'), 4365 )
#
Druid(
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
password=None,
port=None,
port_override=None,
secret_store_id=None,
tags=None,
username=None
)
View Source
4262 def __init__( 4263 self, 4264 egress_filter=None, 4265 healthy=None, 4266 hostname=None, 4267 id=None, 4268 name=None, 4269 password=None, 4270 port=None, 4271 port_override=None, 4272 secret_store_id=None, 4273 tags=None, 4274 username=None, 4275 ): 4276 self.egress_filter = egress_filter if egress_filter is not None else '' 4277 ''' 4278 A filter applied to the routing logic to pin datasource to nodes. 4279 ''' 4280 self.healthy = healthy if healthy is not None else False 4281 ''' 4282 True if the datasource is reachable and the credentials are valid. 4283 ''' 4284 self.hostname = hostname if hostname is not None else '' 4285 ''' 4286 4287 ''' 4288 self.id = id if id is not None else '' 4289 ''' 4290 Unique identifier of the Resource. 4291 ''' 4292 self.name = name if name is not None else '' 4293 ''' 4294 Unique human-readable name of the Resource. 4295 ''' 4296 self.password = password if password is not None else '' 4297 ''' 4298 4299 ''' 4300 self.port = port if port is not None else 0 4301 ''' 4302 4303 ''' 4304 self.port_override = port_override if port_override is not None else 0 4305 ''' 4306 4307 ''' 4308 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 4309 ''' 4310 ID of the secret store containing credentials for this resource, if any. 4311 ''' 4312 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 4313 ''' 4314 Tags is a map of key, value pairs. 4315 ''' 4316 self.username = username if username is not None else '' 4317 ''' 4318 4319 '''
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
password
#
port
#
port_override
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
username
View Source
4336 def to_dict(self): 4337 return { 4338 'egress_filter': self.egress_filter, 4339 'healthy': self.healthy, 4340 'hostname': self.hostname, 4341 'id': self.id, 4342 'name': self.name, 4343 'password': self.password, 4344 'port': self.port, 4345 'port_override': self.port_override, 4346 'secret_store_id': self.secret_store_id, 4347 'tags': self.tags, 4348 'username': self.username, 4349 }
View Source
4351 @classmethod 4352 def from_dict(cls, d): 4353 return cls( 4354 egress_filter=d.get('egress_filter'), 4355 healthy=d.get('healthy'), 4356 hostname=d.get('hostname'), 4357 id=d.get('id'), 4358 name=d.get('name'), 4359 password=d.get('password'), 4360 port=d.get('port'), 4361 port_override=d.get('port_override'), 4362 secret_store_id=d.get('secret_store_id'), 4363 tags=d.get('tags'), 4364 username=d.get('username'), 4365 )
View Source
4368class DynamoDB: 4369 ''' 4370 4371 ''' 4372 __slots__ = [ 4373 'access_key', 4374 'egress_filter', 4375 'endpoint', 4376 'healthy', 4377 'id', 4378 'name', 4379 'port_override', 4380 'region', 4381 'role_arn', 4382 'role_external_id', 4383 'secret_access_key', 4384 'secret_store_id', 4385 'tags', 4386 ] 4387 4388 def __init__( 4389 self, 4390 access_key=None, 4391 egress_filter=None, 4392 endpoint=None, 4393 healthy=None, 4394 id=None, 4395 name=None, 4396 port_override=None, 4397 region=None, 4398 role_arn=None, 4399 role_external_id=None, 4400 secret_access_key=None, 4401 secret_store_id=None, 4402 tags=None, 4403 ): 4404 self.access_key = access_key if access_key is not None else '' 4405 ''' 4406 4407 ''' 4408 self.egress_filter = egress_filter if egress_filter is not None else '' 4409 ''' 4410 A filter applied to the routing logic to pin datasource to nodes. 4411 ''' 4412 self.endpoint = endpoint if endpoint is not None else '' 4413 ''' 4414 4415 ''' 4416 self.healthy = healthy if healthy is not None else False 4417 ''' 4418 True if the datasource is reachable and the credentials are valid. 4419 ''' 4420 self.id = id if id is not None else '' 4421 ''' 4422 Unique identifier of the Resource. 4423 ''' 4424 self.name = name if name is not None else '' 4425 ''' 4426 Unique human-readable name of the Resource. 4427 ''' 4428 self.port_override = port_override if port_override is not None else 0 4429 ''' 4430 4431 ''' 4432 self.region = region if region is not None else '' 4433 ''' 4434 4435 ''' 4436 self.role_arn = role_arn if role_arn is not None else '' 4437 ''' 4438 4439 ''' 4440 self.role_external_id = role_external_id if role_external_id is not None else '' 4441 ''' 4442 4443 ''' 4444 self.secret_access_key = secret_access_key if secret_access_key is not None else '' 4445 ''' 4446 4447 ''' 4448 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 4449 ''' 4450 ID of the secret store containing credentials for this resource, if any. 4451 ''' 4452 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 4453 ''' 4454 Tags is a map of key, value pairs. 4455 ''' 4456 4457 def __repr__(self): 4458 return '<sdm.DynamoDB ' + \ 4459 'access_key: ' + repr(self.access_key) + ' ' +\ 4460 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 4461 'endpoint: ' + repr(self.endpoint) + ' ' +\ 4462 'healthy: ' + repr(self.healthy) + ' ' +\ 4463 'id: ' + repr(self.id) + ' ' +\ 4464 'name: ' + repr(self.name) + ' ' +\ 4465 'port_override: ' + repr(self.port_override) + ' ' +\ 4466 'region: ' + repr(self.region) + ' ' +\ 4467 'role_arn: ' + repr(self.role_arn) + ' ' +\ 4468 'role_external_id: ' + repr(self.role_external_id) + ' ' +\ 4469 'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\ 4470 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 4471 'tags: ' + repr(self.tags) + ' ' +\ 4472 '>' 4473 4474 def to_dict(self): 4475 return { 4476 'access_key': self.access_key, 4477 'egress_filter': self.egress_filter, 4478 'endpoint': self.endpoint, 4479 'healthy': self.healthy, 4480 'id': self.id, 4481 'name': self.name, 4482 'port_override': self.port_override, 4483 'region': self.region, 4484 'role_arn': self.role_arn, 4485 'role_external_id': self.role_external_id, 4486 'secret_access_key': self.secret_access_key, 4487 'secret_store_id': self.secret_store_id, 4488 'tags': self.tags, 4489 } 4490 4491 @classmethod 4492 def from_dict(cls, d): 4493 return cls( 4494 access_key=d.get('access_key'), 4495 egress_filter=d.get('egress_filter'), 4496 endpoint=d.get('endpoint'), 4497 healthy=d.get('healthy'), 4498 id=d.get('id'), 4499 name=d.get('name'), 4500 port_override=d.get('port_override'), 4501 region=d.get('region'), 4502 role_arn=d.get('role_arn'), 4503 role_external_id=d.get('role_external_id'), 4504 secret_access_key=d.get('secret_access_key'), 4505 secret_store_id=d.get('secret_store_id'), 4506 tags=d.get('tags'), 4507 )
#
DynamoDB(
access_key=None,
egress_filter=None,
endpoint=None,
healthy=None,
id=None,
name=None,
port_override=None,
region=None,
role_arn=None,
role_external_id=None,
secret_access_key=None,
secret_store_id=None,
tags=None
)
View Source
4388 def __init__( 4389 self, 4390 access_key=None, 4391 egress_filter=None, 4392 endpoint=None, 4393 healthy=None, 4394 id=None, 4395 name=None, 4396 port_override=None, 4397 region=None, 4398 role_arn=None, 4399 role_external_id=None, 4400 secret_access_key=None, 4401 secret_store_id=None, 4402 tags=None, 4403 ): 4404 self.access_key = access_key if access_key is not None else '' 4405 ''' 4406 4407 ''' 4408 self.egress_filter = egress_filter if egress_filter is not None else '' 4409 ''' 4410 A filter applied to the routing logic to pin datasource to nodes. 4411 ''' 4412 self.endpoint = endpoint if endpoint is not None else '' 4413 ''' 4414 4415 ''' 4416 self.healthy = healthy if healthy is not None else False 4417 ''' 4418 True if the datasource is reachable and the credentials are valid. 4419 ''' 4420 self.id = id if id is not None else '' 4421 ''' 4422 Unique identifier of the Resource. 4423 ''' 4424 self.name = name if name is not None else '' 4425 ''' 4426 Unique human-readable name of the Resource. 4427 ''' 4428 self.port_override = port_override if port_override is not None else 0 4429 ''' 4430 4431 ''' 4432 self.region = region if region is not None else '' 4433 ''' 4434 4435 ''' 4436 self.role_arn = role_arn if role_arn is not None else '' 4437 ''' 4438 4439 ''' 4440 self.role_external_id = role_external_id if role_external_id is not None else '' 4441 ''' 4442 4443 ''' 4444 self.secret_access_key = secret_access_key if secret_access_key is not None else '' 4445 ''' 4446 4447 ''' 4448 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 4449 ''' 4450 ID of the secret store containing credentials for this resource, if any. 4451 ''' 4452 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 4453 ''' 4454 Tags is a map of key, value pairs. 4455 '''
#
access_key
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
endpoint
#
healthy
True if the datasource is reachable and the credentials are valid.
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
port_override
#
region
#
role_arn
#
role_external_id
#
secret_access_key
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
View Source
4474 def to_dict(self): 4475 return { 4476 'access_key': self.access_key, 4477 'egress_filter': self.egress_filter, 4478 'endpoint': self.endpoint, 4479 'healthy': self.healthy, 4480 'id': self.id, 4481 'name': self.name, 4482 'port_override': self.port_override, 4483 'region': self.region, 4484 'role_arn': self.role_arn, 4485 'role_external_id': self.role_external_id, 4486 'secret_access_key': self.secret_access_key, 4487 'secret_store_id': self.secret_store_id, 4488 'tags': self.tags, 4489 }
View Source
4491 @classmethod 4492 def from_dict(cls, d): 4493 return cls( 4494 access_key=d.get('access_key'), 4495 egress_filter=d.get('egress_filter'), 4496 endpoint=d.get('endpoint'), 4497 healthy=d.get('healthy'), 4498 id=d.get('id'), 4499 name=d.get('name'), 4500 port_override=d.get('port_override'), 4501 region=d.get('region'), 4502 role_arn=d.get('role_arn'), 4503 role_external_id=d.get('role_external_id'), 4504 secret_access_key=d.get('secret_access_key'), 4505 secret_store_id=d.get('secret_store_id'), 4506 tags=d.get('tags'), 4507 )
View Source
4510class Elastic: 4511 ''' 4512 4513 ''' 4514 __slots__ = [ 4515 'egress_filter', 4516 'healthy', 4517 'hostname', 4518 'id', 4519 'name', 4520 'password', 4521 'port', 4522 'port_override', 4523 'secret_store_id', 4524 'tags', 4525 'tls_required', 4526 'username', 4527 ] 4528 4529 def __init__( 4530 self, 4531 egress_filter=None, 4532 healthy=None, 4533 hostname=None, 4534 id=None, 4535 name=None, 4536 password=None, 4537 port=None, 4538 port_override=None, 4539 secret_store_id=None, 4540 tags=None, 4541 tls_required=None, 4542 username=None, 4543 ): 4544 self.egress_filter = egress_filter if egress_filter is not None else '' 4545 ''' 4546 A filter applied to the routing logic to pin datasource to nodes. 4547 ''' 4548 self.healthy = healthy if healthy is not None else False 4549 ''' 4550 True if the datasource is reachable and the credentials are valid. 4551 ''' 4552 self.hostname = hostname if hostname is not None else '' 4553 ''' 4554 4555 ''' 4556 self.id = id if id is not None else '' 4557 ''' 4558 Unique identifier of the Resource. 4559 ''' 4560 self.name = name if name is not None else '' 4561 ''' 4562 Unique human-readable name of the Resource. 4563 ''' 4564 self.password = password if password is not None else '' 4565 ''' 4566 4567 ''' 4568 self.port = port if port is not None else 0 4569 ''' 4570 4571 ''' 4572 self.port_override = port_override if port_override is not None else 0 4573 ''' 4574 4575 ''' 4576 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 4577 ''' 4578 ID of the secret store containing credentials for this resource, if any. 4579 ''' 4580 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 4581 ''' 4582 Tags is a map of key, value pairs. 4583 ''' 4584 self.tls_required = tls_required if tls_required is not None else False 4585 ''' 4586 4587 ''' 4588 self.username = username if username is not None else '' 4589 ''' 4590 4591 ''' 4592 4593 def __repr__(self): 4594 return '<sdm.Elastic ' + \ 4595 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 4596 'healthy: ' + repr(self.healthy) + ' ' +\ 4597 'hostname: ' + repr(self.hostname) + ' ' +\ 4598 'id: ' + repr(self.id) + ' ' +\ 4599 'name: ' + repr(self.name) + ' ' +\ 4600 'password: ' + repr(self.password) + ' ' +\ 4601 'port: ' + repr(self.port) + ' ' +\ 4602 'port_override: ' + repr(self.port_override) + ' ' +\ 4603 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 4604 'tags: ' + repr(self.tags) + ' ' +\ 4605 'tls_required: ' + repr(self.tls_required) + ' ' +\ 4606 'username: ' + repr(self.username) + ' ' +\ 4607 '>' 4608 4609 def to_dict(self): 4610 return { 4611 'egress_filter': self.egress_filter, 4612 'healthy': self.healthy, 4613 'hostname': self.hostname, 4614 'id': self.id, 4615 'name': self.name, 4616 'password': self.password, 4617 'port': self.port, 4618 'port_override': self.port_override, 4619 'secret_store_id': self.secret_store_id, 4620 'tags': self.tags, 4621 'tls_required': self.tls_required, 4622 'username': self.username, 4623 } 4624 4625 @classmethod 4626 def from_dict(cls, d): 4627 return cls( 4628 egress_filter=d.get('egress_filter'), 4629 healthy=d.get('healthy'), 4630 hostname=d.get('hostname'), 4631 id=d.get('id'), 4632 name=d.get('name'), 4633 password=d.get('password'), 4634 port=d.get('port'), 4635 port_override=d.get('port_override'), 4636 secret_store_id=d.get('secret_store_id'), 4637 tags=d.get('tags'), 4638 tls_required=d.get('tls_required'), 4639 username=d.get('username'), 4640 )
#
Elastic(
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
password=None,
port=None,
port_override=None,
secret_store_id=None,
tags=None,
tls_required=None,
username=None
)
View Source
4529 def __init__( 4530 self, 4531 egress_filter=None, 4532 healthy=None, 4533 hostname=None, 4534 id=None, 4535 name=None, 4536 password=None, 4537 port=None, 4538 port_override=None, 4539 secret_store_id=None, 4540 tags=None, 4541 tls_required=None, 4542 username=None, 4543 ): 4544 self.egress_filter = egress_filter if egress_filter is not None else '' 4545 ''' 4546 A filter applied to the routing logic to pin datasource to nodes. 4547 ''' 4548 self.healthy = healthy if healthy is not None else False 4549 ''' 4550 True if the datasource is reachable and the credentials are valid. 4551 ''' 4552 self.hostname = hostname if hostname is not None else '' 4553 ''' 4554 4555 ''' 4556 self.id = id if id is not None else '' 4557 ''' 4558 Unique identifier of the Resource. 4559 ''' 4560 self.name = name if name is not None else '' 4561 ''' 4562 Unique human-readable name of the Resource. 4563 ''' 4564 self.password = password if password is not None else '' 4565 ''' 4566 4567 ''' 4568 self.port = port if port is not None else 0 4569 ''' 4570 4571 ''' 4572 self.port_override = port_override if port_override is not None else 0 4573 ''' 4574 4575 ''' 4576 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 4577 ''' 4578 ID of the secret store containing credentials for this resource, if any. 4579 ''' 4580 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 4581 ''' 4582 Tags is a map of key, value pairs. 4583 ''' 4584 self.tls_required = tls_required if tls_required is not None else False 4585 ''' 4586 4587 ''' 4588 self.username = username if username is not None else '' 4589 ''' 4590 4591 '''
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
password
#
port
#
port_override
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
tls_required
#
username
View Source
4609 def to_dict(self): 4610 return { 4611 'egress_filter': self.egress_filter, 4612 'healthy': self.healthy, 4613 'hostname': self.hostname, 4614 'id': self.id, 4615 'name': self.name, 4616 'password': self.password, 4617 'port': self.port, 4618 'port_override': self.port_override, 4619 'secret_store_id': self.secret_store_id, 4620 'tags': self.tags, 4621 'tls_required': self.tls_required, 4622 'username': self.username, 4623 }
View Source
4625 @classmethod 4626 def from_dict(cls, d): 4627 return cls( 4628 egress_filter=d.get('egress_filter'), 4629 healthy=d.get('healthy'), 4630 hostname=d.get('hostname'), 4631 id=d.get('id'), 4632 name=d.get('name'), 4633 password=d.get('password'), 4634 port=d.get('port'), 4635 port_override=d.get('port_override'), 4636 secret_store_id=d.get('secret_store_id'), 4637 tags=d.get('tags'), 4638 tls_required=d.get('tls_required'), 4639 username=d.get('username'), 4640 )
View Source
4643class ElasticacheRedis: 4644 ''' 4645 4646 ''' 4647 __slots__ = [ 4648 'egress_filter', 4649 'healthy', 4650 'hostname', 4651 'id', 4652 'name', 4653 'password', 4654 'port', 4655 'port_override', 4656 'secret_store_id', 4657 'tags', 4658 'tls_required', 4659 ] 4660 4661 def __init__( 4662 self, 4663 egress_filter=None, 4664 healthy=None, 4665 hostname=None, 4666 id=None, 4667 name=None, 4668 password=None, 4669 port=None, 4670 port_override=None, 4671 secret_store_id=None, 4672 tags=None, 4673 tls_required=None, 4674 ): 4675 self.egress_filter = egress_filter if egress_filter is not None else '' 4676 ''' 4677 A filter applied to the routing logic to pin datasource to nodes. 4678 ''' 4679 self.healthy = healthy if healthy is not None else False 4680 ''' 4681 True if the datasource is reachable and the credentials are valid. 4682 ''' 4683 self.hostname = hostname if hostname is not None else '' 4684 ''' 4685 4686 ''' 4687 self.id = id if id is not None else '' 4688 ''' 4689 Unique identifier of the Resource. 4690 ''' 4691 self.name = name if name is not None else '' 4692 ''' 4693 Unique human-readable name of the Resource. 4694 ''' 4695 self.password = password if password is not None else '' 4696 ''' 4697 4698 ''' 4699 self.port = port if port is not None else 0 4700 ''' 4701 4702 ''' 4703 self.port_override = port_override if port_override is not None else 0 4704 ''' 4705 4706 ''' 4707 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 4708 ''' 4709 ID of the secret store containing credentials for this resource, if any. 4710 ''' 4711 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 4712 ''' 4713 Tags is a map of key, value pairs. 4714 ''' 4715 self.tls_required = tls_required if tls_required is not None else False 4716 ''' 4717 4718 ''' 4719 4720 def __repr__(self): 4721 return '<sdm.ElasticacheRedis ' + \ 4722 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 4723 'healthy: ' + repr(self.healthy) + ' ' +\ 4724 'hostname: ' + repr(self.hostname) + ' ' +\ 4725 'id: ' + repr(self.id) + ' ' +\ 4726 'name: ' + repr(self.name) + ' ' +\ 4727 'password: ' + repr(self.password) + ' ' +\ 4728 'port: ' + repr(self.port) + ' ' +\ 4729 'port_override: ' + repr(self.port_override) + ' ' +\ 4730 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 4731 'tags: ' + repr(self.tags) + ' ' +\ 4732 'tls_required: ' + repr(self.tls_required) + ' ' +\ 4733 '>' 4734 4735 def to_dict(self): 4736 return { 4737 'egress_filter': self.egress_filter, 4738 'healthy': self.healthy, 4739 'hostname': self.hostname, 4740 'id': self.id, 4741 'name': self.name, 4742 'password': self.password, 4743 'port': self.port, 4744 'port_override': self.port_override, 4745 'secret_store_id': self.secret_store_id, 4746 'tags': self.tags, 4747 'tls_required': self.tls_required, 4748 } 4749 4750 @classmethod 4751 def from_dict(cls, d): 4752 return cls( 4753 egress_filter=d.get('egress_filter'), 4754 healthy=d.get('healthy'), 4755 hostname=d.get('hostname'), 4756 id=d.get('id'), 4757 name=d.get('name'), 4758 password=d.get('password'), 4759 port=d.get('port'), 4760 port_override=d.get('port_override'), 4761 secret_store_id=d.get('secret_store_id'), 4762 tags=d.get('tags'), 4763 tls_required=d.get('tls_required'), 4764 )
#
ElasticacheRedis(
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
password=None,
port=None,
port_override=None,
secret_store_id=None,
tags=None,
tls_required=None
)
View Source
4661 def __init__( 4662 self, 4663 egress_filter=None, 4664 healthy=None, 4665 hostname=None, 4666 id=None, 4667 name=None, 4668 password=None, 4669 port=None, 4670 port_override=None, 4671 secret_store_id=None, 4672 tags=None, 4673 tls_required=None, 4674 ): 4675 self.egress_filter = egress_filter if egress_filter is not None else '' 4676 ''' 4677 A filter applied to the routing logic to pin datasource to nodes. 4678 ''' 4679 self.healthy = healthy if healthy is not None else False 4680 ''' 4681 True if the datasource is reachable and the credentials are valid. 4682 ''' 4683 self.hostname = hostname if hostname is not None else '' 4684 ''' 4685 4686 ''' 4687 self.id = id if id is not None else '' 4688 ''' 4689 Unique identifier of the Resource. 4690 ''' 4691 self.name = name if name is not None else '' 4692 ''' 4693 Unique human-readable name of the Resource. 4694 ''' 4695 self.password = password if password is not None else '' 4696 ''' 4697 4698 ''' 4699 self.port = port if port is not None else 0 4700 ''' 4701 4702 ''' 4703 self.port_override = port_override if port_override is not None else 0 4704 ''' 4705 4706 ''' 4707 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 4708 ''' 4709 ID of the secret store containing credentials for this resource, if any. 4710 ''' 4711 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 4712 ''' 4713 Tags is a map of key, value pairs. 4714 ''' 4715 self.tls_required = tls_required if tls_required is not None else False 4716 ''' 4717 4718 '''
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
password
#
port
#
port_override
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
tls_required
View Source
4735 def to_dict(self): 4736 return { 4737 'egress_filter': self.egress_filter, 4738 'healthy': self.healthy, 4739 'hostname': self.hostname, 4740 'id': self.id, 4741 'name': self.name, 4742 'password': self.password, 4743 'port': self.port, 4744 'port_override': self.port_override, 4745 'secret_store_id': self.secret_store_id, 4746 'tags': self.tags, 4747 'tls_required': self.tls_required, 4748 }
View Source
4750 @classmethod 4751 def from_dict(cls, d): 4752 return cls( 4753 egress_filter=d.get('egress_filter'), 4754 healthy=d.get('healthy'), 4755 hostname=d.get('hostname'), 4756 id=d.get('id'), 4757 name=d.get('name'), 4758 password=d.get('password'), 4759 port=d.get('port'), 4760 port_override=d.get('port_override'), 4761 secret_store_id=d.get('secret_store_id'), 4762 tags=d.get('tags'), 4763 tls_required=d.get('tls_required'), 4764 )
View Source
4767class GCP: 4768 ''' 4769 4770 ''' 4771 __slots__ = [ 4772 'egress_filter', 4773 'healthy', 4774 'id', 4775 'keyfile', 4776 'name', 4777 'scopes', 4778 'secret_store_id', 4779 'tags', 4780 ] 4781 4782 def __init__( 4783 self, 4784 egress_filter=None, 4785 healthy=None, 4786 id=None, 4787 keyfile=None, 4788 name=None, 4789 scopes=None, 4790 secret_store_id=None, 4791 tags=None, 4792 ): 4793 self.egress_filter = egress_filter if egress_filter is not None else '' 4794 ''' 4795 A filter applied to the routing logic to pin datasource to nodes. 4796 ''' 4797 self.healthy = healthy if healthy is not None else False 4798 ''' 4799 True if the datasource is reachable and the credentials are valid. 4800 ''' 4801 self.id = id if id is not None else '' 4802 ''' 4803 Unique identifier of the Resource. 4804 ''' 4805 self.keyfile = keyfile if keyfile is not None else '' 4806 ''' 4807 4808 ''' 4809 self.name = name if name is not None else '' 4810 ''' 4811 Unique human-readable name of the Resource. 4812 ''' 4813 self.scopes = scopes if scopes is not None else '' 4814 ''' 4815 4816 ''' 4817 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 4818 ''' 4819 ID of the secret store containing credentials for this resource, if any. 4820 ''' 4821 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 4822 ''' 4823 Tags is a map of key, value pairs. 4824 ''' 4825 4826 def __repr__(self): 4827 return '<sdm.GCP ' + \ 4828 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 4829 'healthy: ' + repr(self.healthy) + ' ' +\ 4830 'id: ' + repr(self.id) + ' ' +\ 4831 'keyfile: ' + repr(self.keyfile) + ' ' +\ 4832 'name: ' + repr(self.name) + ' ' +\ 4833 'scopes: ' + repr(self.scopes) + ' ' +\ 4834 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 4835 'tags: ' + repr(self.tags) + ' ' +\ 4836 '>' 4837 4838 def to_dict(self): 4839 return { 4840 'egress_filter': self.egress_filter, 4841 'healthy': self.healthy, 4842 'id': self.id, 4843 'keyfile': self.keyfile, 4844 'name': self.name, 4845 'scopes': self.scopes, 4846 'secret_store_id': self.secret_store_id, 4847 'tags': self.tags, 4848 } 4849 4850 @classmethod 4851 def from_dict(cls, d): 4852 return cls( 4853 egress_filter=d.get('egress_filter'), 4854 healthy=d.get('healthy'), 4855 id=d.get('id'), 4856 keyfile=d.get('keyfile'), 4857 name=d.get('name'), 4858 scopes=d.get('scopes'), 4859 secret_store_id=d.get('secret_store_id'), 4860 tags=d.get('tags'), 4861 )
#
GCP(
egress_filter=None,
healthy=None,
id=None,
keyfile=None,
name=None,
scopes=None,
secret_store_id=None,
tags=None
)
View Source
4782 def __init__( 4783 self, 4784 egress_filter=None, 4785 healthy=None, 4786 id=None, 4787 keyfile=None, 4788 name=None, 4789 scopes=None, 4790 secret_store_id=None, 4791 tags=None, 4792 ): 4793 self.egress_filter = egress_filter if egress_filter is not None else '' 4794 ''' 4795 A filter applied to the routing logic to pin datasource to nodes. 4796 ''' 4797 self.healthy = healthy if healthy is not None else False 4798 ''' 4799 True if the datasource is reachable and the credentials are valid. 4800 ''' 4801 self.id = id if id is not None else '' 4802 ''' 4803 Unique identifier of the Resource. 4804 ''' 4805 self.keyfile = keyfile if keyfile is not None else '' 4806 ''' 4807 4808 ''' 4809 self.name = name if name is not None else '' 4810 ''' 4811 Unique human-readable name of the Resource. 4812 ''' 4813 self.scopes = scopes if scopes is not None else '' 4814 ''' 4815 4816 ''' 4817 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 4818 ''' 4819 ID of the secret store containing credentials for this resource, if any. 4820 ''' 4821 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 4822 ''' 4823 Tags is a map of key, value pairs. 4824 '''
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
id
Unique identifier of the Resource.
#
keyfile
#
name
Unique human-readable name of the Resource.
#
scopes
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
View Source
View Source
4850 @classmethod 4851 def from_dict(cls, d): 4852 return cls( 4853 egress_filter=d.get('egress_filter'), 4854 healthy=d.get('healthy'), 4855 id=d.get('id'), 4856 keyfile=d.get('keyfile'), 4857 name=d.get('name'), 4858 scopes=d.get('scopes'), 4859 secret_store_id=d.get('secret_store_id'), 4860 tags=d.get('tags'), 4861 )
View Source
4864class GCPStore: 4865 ''' 4866 4867 ''' 4868 __slots__ = [ 4869 'id', 4870 'name', 4871 'projectid', 4872 'tags', 4873 ] 4874 4875 def __init__( 4876 self, 4877 id=None, 4878 name=None, 4879 projectid=None, 4880 tags=None, 4881 ): 4882 self.id = id if id is not None else '' 4883 ''' 4884 Unique identifier of the SecretStore. 4885 ''' 4886 self.name = name if name is not None else '' 4887 ''' 4888 Unique human-readable name of the SecretStore. 4889 ''' 4890 self.projectid = projectid if projectid is not None else '' 4891 ''' 4892 4893 ''' 4894 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 4895 ''' 4896 Tags is a map of key, value pairs. 4897 ''' 4898 4899 def __repr__(self): 4900 return '<sdm.GCPStore ' + \ 4901 'id: ' + repr(self.id) + ' ' +\ 4902 'name: ' + repr(self.name) + ' ' +\ 4903 'projectid: ' + repr(self.projectid) + ' ' +\ 4904 'tags: ' + repr(self.tags) + ' ' +\ 4905 '>' 4906 4907 def to_dict(self): 4908 return { 4909 'id': self.id, 4910 'name': self.name, 4911 'projectid': self.projectid, 4912 'tags': self.tags, 4913 } 4914 4915 @classmethod 4916 def from_dict(cls, d): 4917 return cls( 4918 id=d.get('id'), 4919 name=d.get('name'), 4920 projectid=d.get('projectid'), 4921 tags=d.get('tags'), 4922 )
View Source
4875 def __init__( 4876 self, 4877 id=None, 4878 name=None, 4879 projectid=None, 4880 tags=None, 4881 ): 4882 self.id = id if id is not None else '' 4883 ''' 4884 Unique identifier of the SecretStore. 4885 ''' 4886 self.name = name if name is not None else '' 4887 ''' 4888 Unique human-readable name of the SecretStore. 4889 ''' 4890 self.projectid = projectid if projectid is not None else '' 4891 ''' 4892 4893 ''' 4894 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 4895 ''' 4896 Tags is a map of key, value pairs. 4897 '''
#
id
Unique identifier of the SecretStore.
#
name
Unique human-readable name of the SecretStore.
#
projectid
View Source
4925class Gateway: 4926 ''' 4927 Gateway represents a StrongDM CLI installation running in gateway mode. 4928 ''' 4929 __slots__ = [ 4930 'bind_address', 4931 'gateway_filter', 4932 'id', 4933 'listen_address', 4934 'name', 4935 'state', 4936 'tags', 4937 ] 4938 4939 def __init__( 4940 self, 4941 bind_address=None, 4942 gateway_filter=None, 4943 id=None, 4944 listen_address=None, 4945 name=None, 4946 state=None, 4947 tags=None, 4948 ): 4949 self.bind_address = bind_address if bind_address is not None else '' 4950 ''' 4951 The hostname/port tuple which the gateway daemon will bind to. 4952 If not provided on create, set to "0.0.0.0:listen_address_port". 4953 ''' 4954 self.gateway_filter = gateway_filter if gateway_filter is not None else '' 4955 ''' 4956 GatewayFilter can be used to restrict the peering between relays and 4957 gateways. 4958 ''' 4959 self.id = id if id is not None else '' 4960 ''' 4961 Unique identifier of the Gateway. 4962 ''' 4963 self.listen_address = listen_address if listen_address is not None else '' 4964 ''' 4965 The public hostname/port tuple at which the gateway will be accessible to clients. 4966 ''' 4967 self.name = name if name is not None else '' 4968 ''' 4969 Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create. 4970 ''' 4971 self.state = state if state is not None else '' 4972 ''' 4973 The current state of the gateway. One of: "new", "verifying_restart", 4974 "restarting", "started", "stopped", "dead", "unknown" 4975 ''' 4976 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 4977 ''' 4978 Tags is a map of key, value pairs. 4979 ''' 4980 4981 def __repr__(self): 4982 return '<sdm.Gateway ' + \ 4983 'bind_address: ' + repr(self.bind_address) + ' ' +\ 4984 'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\ 4985 'id: ' + repr(self.id) + ' ' +\ 4986 'listen_address: ' + repr(self.listen_address) + ' ' +\ 4987 'name: ' + repr(self.name) + ' ' +\ 4988 'state: ' + repr(self.state) + ' ' +\ 4989 'tags: ' + repr(self.tags) + ' ' +\ 4990 '>' 4991 4992 def to_dict(self): 4993 return { 4994 'bind_address': self.bind_address, 4995 'gateway_filter': self.gateway_filter, 4996 'id': self.id, 4997 'listen_address': self.listen_address, 4998 'name': self.name, 4999 'state': self.state, 5000 'tags': self.tags, 5001 } 5002 5003 @classmethod 5004 def from_dict(cls, d): 5005 return cls( 5006 bind_address=d.get('bind_address'), 5007 gateway_filter=d.get('gateway_filter'), 5008 id=d.get('id'), 5009 listen_address=d.get('listen_address'), 5010 name=d.get('name'), 5011 state=d.get('state'), 5012 tags=d.get('tags'), 5013 )
Gateway represents a StrongDM CLI installation running in gateway mode.
#
Gateway(
bind_address=None,
gateway_filter=None,
id=None,
listen_address=None,
name=None,
state=None,
tags=None
)
View Source
4939 def __init__( 4940 self, 4941 bind_address=None, 4942 gateway_filter=None, 4943 id=None, 4944 listen_address=None, 4945 name=None, 4946 state=None, 4947 tags=None, 4948 ): 4949 self.bind_address = bind_address if bind_address is not None else '' 4950 ''' 4951 The hostname/port tuple which the gateway daemon will bind to. 4952 If not provided on create, set to "0.0.0.0:listen_address_port". 4953 ''' 4954 self.gateway_filter = gateway_filter if gateway_filter is not None else '' 4955 ''' 4956 GatewayFilter can be used to restrict the peering between relays and 4957 gateways. 4958 ''' 4959 self.id = id if id is not None else '' 4960 ''' 4961 Unique identifier of the Gateway. 4962 ''' 4963 self.listen_address = listen_address if listen_address is not None else '' 4964 ''' 4965 The public hostname/port tuple at which the gateway will be accessible to clients. 4966 ''' 4967 self.name = name if name is not None else '' 4968 ''' 4969 Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create. 4970 ''' 4971 self.state = state if state is not None else '' 4972 ''' 4973 The current state of the gateway. One of: "new", "verifying_restart", 4974 "restarting", "started", "stopped", "dead", "unknown" 4975 ''' 4976 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 4977 ''' 4978 Tags is a map of key, value pairs. 4979 '''
#
bind_address
The hostname/port tuple which the gateway daemon will bind to. If not provided on create, set to "0.0.0.0:listen_address_port".
#
gateway_filter
GatewayFilter can be used to restrict the peering between relays and gateways.
#
id
Unique identifier of the Gateway.
#
listen_address
The public hostname/port tuple at which the gateway will be accessible to clients.
#
name
Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
#
state
The current state of the gateway. One of: "new", "verifying_restart", "restarting", "started", "stopped", "dead", "unknown"
View Source
View Source
5016class GetResponseMetadata: 5017 ''' 5018 GetResponseMetadata is reserved for future use. 5019 ''' 5020 __slots__ = [] 5021 5022 def __init__(self, ): 5023 pass 5024 5025 def __repr__(self): 5026 return '<sdm.GetResponseMetadata ' + \ 5027 '>' 5028 5029 def to_dict(self): 5030 return {} 5031 5032 @classmethod 5033 def from_dict(cls, d): 5034 return cls()
GetResponseMetadata is reserved for future use.
View Source
5037class GoogleGKE: 5038 ''' 5039 5040 ''' 5041 __slots__ = [ 5042 'certificate_authority', 5043 'egress_filter', 5044 'endpoint', 5045 'healthcheck_namespace', 5046 'healthy', 5047 'id', 5048 'name', 5049 'secret_store_id', 5050 'service_account_key', 5051 'tags', 5052 ] 5053 5054 def __init__( 5055 self, 5056 certificate_authority=None, 5057 egress_filter=None, 5058 endpoint=None, 5059 healthcheck_namespace=None, 5060 healthy=None, 5061 id=None, 5062 name=None, 5063 secret_store_id=None, 5064 service_account_key=None, 5065 tags=None, 5066 ): 5067 self.certificate_authority = certificate_authority if certificate_authority is not None else '' 5068 ''' 5069 5070 ''' 5071 self.egress_filter = egress_filter if egress_filter is not None else '' 5072 ''' 5073 A filter applied to the routing logic to pin datasource to nodes. 5074 ''' 5075 self.endpoint = endpoint if endpoint is not None else '' 5076 ''' 5077 5078 ''' 5079 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 5080 ''' 5081 The path used to check the health of your connection. Defaults to `default`. 5082 ''' 5083 self.healthy = healthy if healthy is not None else False 5084 ''' 5085 True if the datasource is reachable and the credentials are valid. 5086 ''' 5087 self.id = id if id is not None else '' 5088 ''' 5089 Unique identifier of the Resource. 5090 ''' 5091 self.name = name if name is not None else '' 5092 ''' 5093 Unique human-readable name of the Resource. 5094 ''' 5095 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 5096 ''' 5097 ID of the secret store containing credentials for this resource, if any. 5098 ''' 5099 self.service_account_key = service_account_key if service_account_key is not None else '' 5100 ''' 5101 5102 ''' 5103 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 5104 ''' 5105 Tags is a map of key, value pairs. 5106 ''' 5107 5108 def __repr__(self): 5109 return '<sdm.GoogleGKE ' + \ 5110 'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\ 5111 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 5112 'endpoint: ' + repr(self.endpoint) + ' ' +\ 5113 'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\ 5114 'healthy: ' + repr(self.healthy) + ' ' +\ 5115 'id: ' + repr(self.id) + ' ' +\ 5116 'name: ' + repr(self.name) + ' ' +\ 5117 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 5118 'service_account_key: ' + repr(self.service_account_key) + ' ' +\ 5119 'tags: ' + repr(self.tags) + ' ' +\ 5120 '>' 5121 5122 def to_dict(self): 5123 return { 5124 'certificate_authority': self.certificate_authority, 5125 'egress_filter': self.egress_filter, 5126 'endpoint': self.endpoint, 5127 'healthcheck_namespace': self.healthcheck_namespace, 5128 'healthy': self.healthy, 5129 'id': self.id, 5130 'name': self.name, 5131 'secret_store_id': self.secret_store_id, 5132 'service_account_key': self.service_account_key, 5133 'tags': self.tags, 5134 } 5135 5136 @classmethod 5137 def from_dict(cls, d): 5138 return cls( 5139 certificate_authority=d.get('certificate_authority'), 5140 egress_filter=d.get('egress_filter'), 5141 endpoint=d.get('endpoint'), 5142 healthcheck_namespace=d.get('healthcheck_namespace'), 5143 healthy=d.get('healthy'), 5144 id=d.get('id'), 5145 name=d.get('name'), 5146 secret_store_id=d.get('secret_store_id'), 5147 service_account_key=d.get('service_account_key'), 5148 tags=d.get('tags'), 5149 )
#
GoogleGKE(
certificate_authority=None,
egress_filter=None,
endpoint=None,
healthcheck_namespace=None,
healthy=None,
id=None,
name=None,
secret_store_id=None,
service_account_key=None,
tags=None
)
View Source
5054 def __init__( 5055 self, 5056 certificate_authority=None, 5057 egress_filter=None, 5058 endpoint=None, 5059 healthcheck_namespace=None, 5060 healthy=None, 5061 id=None, 5062 name=None, 5063 secret_store_id=None, 5064 service_account_key=None, 5065 tags=None, 5066 ): 5067 self.certificate_authority = certificate_authority if certificate_authority is not None else '' 5068 ''' 5069 5070 ''' 5071 self.egress_filter = egress_filter if egress_filter is not None else '' 5072 ''' 5073 A filter applied to the routing logic to pin datasource to nodes. 5074 ''' 5075 self.endpoint = endpoint if endpoint is not None else '' 5076 ''' 5077 5078 ''' 5079 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 5080 ''' 5081 The path used to check the health of your connection. Defaults to `default`. 5082 ''' 5083 self.healthy = healthy if healthy is not None else False 5084 ''' 5085 True if the datasource is reachable and the credentials are valid. 5086 ''' 5087 self.id = id if id is not None else '' 5088 ''' 5089 Unique identifier of the Resource. 5090 ''' 5091 self.name = name if name is not None else '' 5092 ''' 5093 Unique human-readable name of the Resource. 5094 ''' 5095 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 5096 ''' 5097 ID of the secret store containing credentials for this resource, if any. 5098 ''' 5099 self.service_account_key = service_account_key if service_account_key is not None else '' 5100 ''' 5101 5102 ''' 5103 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 5104 ''' 5105 Tags is a map of key, value pairs. 5106 '''
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
endpoint
#
healthcheck_namespace
The path used to check the health of your connection. Defaults to default.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
service_account_key
View Source
5122 def to_dict(self): 5123 return { 5124 'certificate_authority': self.certificate_authority, 5125 'egress_filter': self.egress_filter, 5126 'endpoint': self.endpoint, 5127 'healthcheck_namespace': self.healthcheck_namespace, 5128 'healthy': self.healthy, 5129 'id': self.id, 5130 'name': self.name, 5131 'secret_store_id': self.secret_store_id, 5132 'service_account_key': self.service_account_key, 5133 'tags': self.tags, 5134 }
View Source
5136 @classmethod 5137 def from_dict(cls, d): 5138 return cls( 5139 certificate_authority=d.get('certificate_authority'), 5140 egress_filter=d.get('egress_filter'), 5141 endpoint=d.get('endpoint'), 5142 healthcheck_namespace=d.get('healthcheck_namespace'), 5143 healthy=d.get('healthy'), 5144 id=d.get('id'), 5145 name=d.get('name'), 5146 secret_store_id=d.get('secret_store_id'), 5147 service_account_key=d.get('service_account_key'), 5148 tags=d.get('tags'), 5149 )
View Source
5152class GoogleGKEUserImpersonation: 5153 ''' 5154 5155 ''' 5156 __slots__ = [ 5157 'certificate_authority', 5158 'egress_filter', 5159 'endpoint', 5160 'healthcheck_namespace', 5161 'healthy', 5162 'id', 5163 'name', 5164 'secret_store_id', 5165 'service_account_key', 5166 'tags', 5167 ] 5168 5169 def __init__( 5170 self, 5171 certificate_authority=None, 5172 egress_filter=None, 5173 endpoint=None, 5174 healthcheck_namespace=None, 5175 healthy=None, 5176 id=None, 5177 name=None, 5178 secret_store_id=None, 5179 service_account_key=None, 5180 tags=None, 5181 ): 5182 self.certificate_authority = certificate_authority if certificate_authority is not None else '' 5183 ''' 5184 5185 ''' 5186 self.egress_filter = egress_filter if egress_filter is not None else '' 5187 ''' 5188 A filter applied to the routing logic to pin datasource to nodes. 5189 ''' 5190 self.endpoint = endpoint if endpoint is not None else '' 5191 ''' 5192 5193 ''' 5194 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 5195 ''' 5196 The path used to check the health of your connection. Defaults to `default`. 5197 ''' 5198 self.healthy = healthy if healthy is not None else False 5199 ''' 5200 True if the datasource is reachable and the credentials are valid. 5201 ''' 5202 self.id = id if id is not None else '' 5203 ''' 5204 Unique identifier of the Resource. 5205 ''' 5206 self.name = name if name is not None else '' 5207 ''' 5208 Unique human-readable name of the Resource. 5209 ''' 5210 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 5211 ''' 5212 ID of the secret store containing credentials for this resource, if any. 5213 ''' 5214 self.service_account_key = service_account_key if service_account_key is not None else '' 5215 ''' 5216 5217 ''' 5218 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 5219 ''' 5220 Tags is a map of key, value pairs. 5221 ''' 5222 5223 def __repr__(self): 5224 return '<sdm.GoogleGKEUserImpersonation ' + \ 5225 'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\ 5226 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 5227 'endpoint: ' + repr(self.endpoint) + ' ' +\ 5228 'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\ 5229 'healthy: ' + repr(self.healthy) + ' ' +\ 5230 'id: ' + repr(self.id) + ' ' +\ 5231 'name: ' + repr(self.name) + ' ' +\ 5232 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 5233 'service_account_key: ' + repr(self.service_account_key) + ' ' +\ 5234 'tags: ' + repr(self.tags) + ' ' +\ 5235 '>' 5236 5237 def to_dict(self): 5238 return { 5239 'certificate_authority': self.certificate_authority, 5240 'egress_filter': self.egress_filter, 5241 'endpoint': self.endpoint, 5242 'healthcheck_namespace': self.healthcheck_namespace, 5243 'healthy': self.healthy, 5244 'id': self.id, 5245 'name': self.name, 5246 'secret_store_id': self.secret_store_id, 5247 'service_account_key': self.service_account_key, 5248 'tags': self.tags, 5249 } 5250 5251 @classmethod 5252 def from_dict(cls, d): 5253 return cls( 5254 certificate_authority=d.get('certificate_authority'), 5255 egress_filter=d.get('egress_filter'), 5256 endpoint=d.get('endpoint'), 5257 healthcheck_namespace=d.get('healthcheck_namespace'), 5258 healthy=d.get('healthy'), 5259 id=d.get('id'), 5260 name=d.get('name'), 5261 secret_store_id=d.get('secret_store_id'), 5262 service_account_key=d.get('service_account_key'), 5263 tags=d.get('tags'), 5264 )
#
GoogleGKEUserImpersonation(
certificate_authority=None,
egress_filter=None,
endpoint=None,
healthcheck_namespace=None,
healthy=None,
id=None,
name=None,
secret_store_id=None,
service_account_key=None,
tags=None
)
View Source
5169 def __init__( 5170 self, 5171 certificate_authority=None, 5172 egress_filter=None, 5173 endpoint=None, 5174 healthcheck_namespace=None, 5175 healthy=None, 5176 id=None, 5177 name=None, 5178 secret_store_id=None, 5179 service_account_key=None, 5180 tags=None, 5181 ): 5182 self.certificate_authority = certificate_authority if certificate_authority is not None else '' 5183 ''' 5184 5185 ''' 5186 self.egress_filter = egress_filter if egress_filter is not None else '' 5187 ''' 5188 A filter applied to the routing logic to pin datasource to nodes. 5189 ''' 5190 self.endpoint = endpoint if endpoint is not None else '' 5191 ''' 5192 5193 ''' 5194 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 5195 ''' 5196 The path used to check the health of your connection. Defaults to `default`. 5197 ''' 5198 self.healthy = healthy if healthy is not None else False 5199 ''' 5200 True if the datasource is reachable and the credentials are valid. 5201 ''' 5202 self.id = id if id is not None else '' 5203 ''' 5204 Unique identifier of the Resource. 5205 ''' 5206 self.name = name if name is not None else '' 5207 ''' 5208 Unique human-readable name of the Resource. 5209 ''' 5210 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 5211 ''' 5212 ID of the secret store containing credentials for this resource, if any. 5213 ''' 5214 self.service_account_key = service_account_key if service_account_key is not None else '' 5215 ''' 5216 5217 ''' 5218 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 5219 ''' 5220 Tags is a map of key, value pairs. 5221 '''
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
endpoint
#
healthcheck_namespace
The path used to check the health of your connection. Defaults to default.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
service_account_key
View Source
5237 def to_dict(self): 5238 return { 5239 'certificate_authority': self.certificate_authority, 5240 'egress_filter': self.egress_filter, 5241 'endpoint': self.endpoint, 5242 'healthcheck_namespace': self.healthcheck_namespace, 5243 'healthy': self.healthy, 5244 'id': self.id, 5245 'name': self.name, 5246 'secret_store_id': self.secret_store_id, 5247 'service_account_key': self.service_account_key, 5248 'tags': self.tags, 5249 }
View Source
5251 @classmethod 5252 def from_dict(cls, d): 5253 return cls( 5254 certificate_authority=d.get('certificate_authority'), 5255 egress_filter=d.get('egress_filter'), 5256 endpoint=d.get('endpoint'), 5257 healthcheck_namespace=d.get('healthcheck_namespace'), 5258 healthy=d.get('healthy'), 5259 id=d.get('id'), 5260 name=d.get('name'), 5261 secret_store_id=d.get('secret_store_id'), 5262 service_account_key=d.get('service_account_key'), 5263 tags=d.get('tags'), 5264 )
View Source
5267class Greenplum: 5268 ''' 5269 5270 ''' 5271 __slots__ = [ 5272 'database', 5273 'egress_filter', 5274 'healthy', 5275 'hostname', 5276 'id', 5277 'name', 5278 'override_database', 5279 'password', 5280 'port', 5281 'port_override', 5282 'secret_store_id', 5283 'tags', 5284 'username', 5285 ] 5286 5287 def __init__( 5288 self, 5289 database=None, 5290 egress_filter=None, 5291 healthy=None, 5292 hostname=None, 5293 id=None, 5294 name=None, 5295 override_database=None, 5296 password=None, 5297 port=None, 5298 port_override=None, 5299 secret_store_id=None, 5300 tags=None, 5301 username=None, 5302 ): 5303 self.database = database if database is not None else '' 5304 ''' 5305 5306 ''' 5307 self.egress_filter = egress_filter if egress_filter is not None else '' 5308 ''' 5309 A filter applied to the routing logic to pin datasource to nodes. 5310 ''' 5311 self.healthy = healthy if healthy is not None else False 5312 ''' 5313 True if the datasource is reachable and the credentials are valid. 5314 ''' 5315 self.hostname = hostname if hostname is not None else '' 5316 ''' 5317 5318 ''' 5319 self.id = id if id is not None else '' 5320 ''' 5321 Unique identifier of the Resource. 5322 ''' 5323 self.name = name if name is not None else '' 5324 ''' 5325 Unique human-readable name of the Resource. 5326 ''' 5327 self.override_database = override_database if override_database is not None else False 5328 ''' 5329 5330 ''' 5331 self.password = password if password is not None else '' 5332 ''' 5333 5334 ''' 5335 self.port = port if port is not None else 0 5336 ''' 5337 5338 ''' 5339 self.port_override = port_override if port_override is not None else 0 5340 ''' 5341 5342 ''' 5343 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 5344 ''' 5345 ID of the secret store containing credentials for this resource, if any. 5346 ''' 5347 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 5348 ''' 5349 Tags is a map of key, value pairs. 5350 ''' 5351 self.username = username if username is not None else '' 5352 ''' 5353 5354 ''' 5355 5356 def __repr__(self): 5357 return '<sdm.Greenplum ' + \ 5358 'database: ' + repr(self.database) + ' ' +\ 5359 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 5360 'healthy: ' + repr(self.healthy) + ' ' +\ 5361 'hostname: ' + repr(self.hostname) + ' ' +\ 5362 'id: ' + repr(self.id) + ' ' +\ 5363 'name: ' + repr(self.name) + ' ' +\ 5364 'override_database: ' + repr(self.override_database) + ' ' +\ 5365 'password: ' + repr(self.password) + ' ' +\ 5366 'port: ' + repr(self.port) + ' ' +\ 5367 'port_override: ' + repr(self.port_override) + ' ' +\ 5368 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 5369 'tags: ' + repr(self.tags) + ' ' +\ 5370 'username: ' + repr(self.username) + ' ' +\ 5371 '>' 5372 5373 def to_dict(self): 5374 return { 5375 'database': self.database, 5376 'egress_filter': self.egress_filter, 5377 'healthy': self.healthy, 5378 'hostname': self.hostname, 5379 'id': self.id, 5380 'name': self.name, 5381 'override_database': self.override_database, 5382 'password': self.password, 5383 'port': self.port, 5384 'port_override': self.port_override, 5385 'secret_store_id': self.secret_store_id, 5386 'tags': self.tags, 5387 'username': self.username, 5388 } 5389 5390 @classmethod 5391 def from_dict(cls, d): 5392 return cls( 5393 database=d.get('database'), 5394 egress_filter=d.get('egress_filter'), 5395 healthy=d.get('healthy'), 5396 hostname=d.get('hostname'), 5397 id=d.get('id'), 5398 name=d.get('name'), 5399 override_database=d.get('override_database'), 5400 password=d.get('password'), 5401 port=d.get('port'), 5402 port_override=d.get('port_override'), 5403 secret_store_id=d.get('secret_store_id'), 5404 tags=d.get('tags'), 5405 username=d.get('username'), 5406 )
#
Greenplum(
database=None,
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
override_database=None,
password=None,
port=None,
port_override=None,
secret_store_id=None,
tags=None,
username=None
)
View Source
5287 def __init__( 5288 self, 5289 database=None, 5290 egress_filter=None, 5291 healthy=None, 5292 hostname=None, 5293 id=None, 5294 name=None, 5295 override_database=None, 5296 password=None, 5297 port=None, 5298 port_override=None, 5299 secret_store_id=None, 5300 tags=None, 5301 username=None, 5302 ): 5303 self.database = database if database is not None else '' 5304 ''' 5305 5306 ''' 5307 self.egress_filter = egress_filter if egress_filter is not None else '' 5308 ''' 5309 A filter applied to the routing logic to pin datasource to nodes. 5310 ''' 5311 self.healthy = healthy if healthy is not None else False 5312 ''' 5313 True if the datasource is reachable and the credentials are valid. 5314 ''' 5315 self.hostname = hostname if hostname is not None else '' 5316 ''' 5317 5318 ''' 5319 self.id = id if id is not None else '' 5320 ''' 5321 Unique identifier of the Resource. 5322 ''' 5323 self.name = name if name is not None else '' 5324 ''' 5325 Unique human-readable name of the Resource. 5326 ''' 5327 self.override_database = override_database if override_database is not None else False 5328 ''' 5329 5330 ''' 5331 self.password = password if password is not None else '' 5332 ''' 5333 5334 ''' 5335 self.port = port if port is not None else 0 5336 ''' 5337 5338 ''' 5339 self.port_override = port_override if port_override is not None else 0 5340 ''' 5341 5342 ''' 5343 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 5344 ''' 5345 ID of the secret store containing credentials for this resource, if any. 5346 ''' 5347 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 5348 ''' 5349 Tags is a map of key, value pairs. 5350 ''' 5351 self.username = username if username is not None else '' 5352 ''' 5353 5354 '''
#
database
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
override_database
#
password
#
port
#
port_override
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
username
View Source
5373 def to_dict(self): 5374 return { 5375 'database': self.database, 5376 'egress_filter': self.egress_filter, 5377 'healthy': self.healthy, 5378 'hostname': self.hostname, 5379 'id': self.id, 5380 'name': self.name, 5381 'override_database': self.override_database, 5382 'password': self.password, 5383 'port': self.port, 5384 'port_override': self.port_override, 5385 'secret_store_id': self.secret_store_id, 5386 'tags': self.tags, 5387 'username': self.username, 5388 }
View Source
5390 @classmethod 5391 def from_dict(cls, d): 5392 return cls( 5393 database=d.get('database'), 5394 egress_filter=d.get('egress_filter'), 5395 healthy=d.get('healthy'), 5396 hostname=d.get('hostname'), 5397 id=d.get('id'), 5398 name=d.get('name'), 5399 override_database=d.get('override_database'), 5400 password=d.get('password'), 5401 port=d.get('port'), 5402 port_override=d.get('port_override'), 5403 secret_store_id=d.get('secret_store_id'), 5404 tags=d.get('tags'), 5405 username=d.get('username'), 5406 )
View Source
5409class HTTPAuth: 5410 ''' 5411 5412 ''' 5413 __slots__ = [ 5414 'auth_header', 5415 'default_path', 5416 'egress_filter', 5417 'headers_blacklist', 5418 'healthcheck_path', 5419 'healthy', 5420 'id', 5421 'name', 5422 'secret_store_id', 5423 'subdomain', 5424 'tags', 5425 'url', 5426 ] 5427 5428 def __init__( 5429 self, 5430 auth_header=None, 5431 default_path=None, 5432 egress_filter=None, 5433 headers_blacklist=None, 5434 healthcheck_path=None, 5435 healthy=None, 5436 id=None, 5437 name=None, 5438 secret_store_id=None, 5439 subdomain=None, 5440 tags=None, 5441 url=None, 5442 ): 5443 self.auth_header = auth_header if auth_header is not None else '' 5444 ''' 5445 5446 ''' 5447 self.default_path = default_path if default_path is not None else '' 5448 ''' 5449 5450 ''' 5451 self.egress_filter = egress_filter if egress_filter is not None else '' 5452 ''' 5453 A filter applied to the routing logic to pin datasource to nodes. 5454 ''' 5455 self.headers_blacklist = headers_blacklist if headers_blacklist is not None else '' 5456 ''' 5457 5458 ''' 5459 self.healthcheck_path = healthcheck_path if healthcheck_path is not None else '' 5460 ''' 5461 5462 ''' 5463 self.healthy = healthy if healthy is not None else False 5464 ''' 5465 True if the datasource is reachable and the credentials are valid. 5466 ''' 5467 self.id = id if id is not None else '' 5468 ''' 5469 Unique identifier of the Resource. 5470 ''' 5471 self.name = name if name is not None else '' 5472 ''' 5473 Unique human-readable name of the Resource. 5474 ''' 5475 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 5476 ''' 5477 ID of the secret store containing credentials for this resource, if any. 5478 ''' 5479 self.subdomain = subdomain if subdomain is not None else '' 5480 ''' 5481 5482 ''' 5483 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 5484 ''' 5485 Tags is a map of key, value pairs. 5486 ''' 5487 self.url = url if url is not None else '' 5488 ''' 5489 5490 ''' 5491 5492 def __repr__(self): 5493 return '<sdm.HTTPAuth ' + \ 5494 'auth_header: ' + repr(self.auth_header) + ' ' +\ 5495 'default_path: ' + repr(self.default_path) + ' ' +\ 5496 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 5497 'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\ 5498 'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\ 5499 'healthy: ' + repr(self.healthy) + ' ' +\ 5500 'id: ' + repr(self.id) + ' ' +\ 5501 'name: ' + repr(self.name) + ' ' +\ 5502 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 5503 'subdomain: ' + repr(self.subdomain) + ' ' +\ 5504 'tags: ' + repr(self.tags) + ' ' +\ 5505 'url: ' + repr(self.url) + ' ' +\ 5506 '>' 5507 5508 def to_dict(self): 5509 return { 5510 'auth_header': self.auth_header, 5511 'default_path': self.default_path, 5512 'egress_filter': self.egress_filter, 5513 'headers_blacklist': self.headers_blacklist, 5514 'healthcheck_path': self.healthcheck_path, 5515 'healthy': self.healthy, 5516 'id': self.id, 5517 'name': self.name, 5518 'secret_store_id': self.secret_store_id, 5519 'subdomain': self.subdomain, 5520 'tags': self.tags, 5521 'url': self.url, 5522 } 5523 5524 @classmethod 5525 def from_dict(cls, d): 5526 return cls( 5527 auth_header=d.get('auth_header'), 5528 default_path=d.get('default_path'), 5529 egress_filter=d.get('egress_filter'), 5530 headers_blacklist=d.get('headers_blacklist'), 5531 healthcheck_path=d.get('healthcheck_path'), 5532 healthy=d.get('healthy'), 5533 id=d.get('id'), 5534 name=d.get('name'), 5535 secret_store_id=d.get('secret_store_id'), 5536 subdomain=d.get('subdomain'), 5537 tags=d.get('tags'), 5538 url=d.get('url'), 5539 )
#
HTTPAuth(
auth_header=None,
default_path=None,
egress_filter=None,
headers_blacklist=None,
healthcheck_path=None,
healthy=None,
id=None,
name=None,
secret_store_id=None,
subdomain=None,
tags=None,
url=None
)
View Source
5428 def __init__( 5429 self, 5430 auth_header=None, 5431 default_path=None, 5432 egress_filter=None, 5433 headers_blacklist=None, 5434 healthcheck_path=None, 5435 healthy=None, 5436 id=None, 5437 name=None, 5438 secret_store_id=None, 5439 subdomain=None, 5440 tags=None, 5441 url=None, 5442 ): 5443 self.auth_header = auth_header if auth_header is not None else '' 5444 ''' 5445 5446 ''' 5447 self.default_path = default_path if default_path is not None else '' 5448 ''' 5449 5450 ''' 5451 self.egress_filter = egress_filter if egress_filter is not None else '' 5452 ''' 5453 A filter applied to the routing logic to pin datasource to nodes. 5454 ''' 5455 self.headers_blacklist = headers_blacklist if headers_blacklist is not None else '' 5456 ''' 5457 5458 ''' 5459 self.healthcheck_path = healthcheck_path if healthcheck_path is not None else '' 5460 ''' 5461 5462 ''' 5463 self.healthy = healthy if healthy is not None else False 5464 ''' 5465 True if the datasource is reachable and the credentials are valid. 5466 ''' 5467 self.id = id if id is not None else '' 5468 ''' 5469 Unique identifier of the Resource. 5470 ''' 5471 self.name = name if name is not None else '' 5472 ''' 5473 Unique human-readable name of the Resource. 5474 ''' 5475 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 5476 ''' 5477 ID of the secret store containing credentials for this resource, if any. 5478 ''' 5479 self.subdomain = subdomain if subdomain is not None else '' 5480 ''' 5481 5482 ''' 5483 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 5484 ''' 5485 Tags is a map of key, value pairs. 5486 ''' 5487 self.url = url if url is not None else '' 5488 ''' 5489 5490 '''
#
auth_header
#
default_path
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
headers_blacklist
#
healthcheck_path
#
healthy
True if the datasource is reachable and the credentials are valid.
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
subdomain
#
url
View Source
5508 def to_dict(self): 5509 return { 5510 'auth_header': self.auth_header, 5511 'default_path': self.default_path, 5512 'egress_filter': self.egress_filter, 5513 'headers_blacklist': self.headers_blacklist, 5514 'healthcheck_path': self.healthcheck_path, 5515 'healthy': self.healthy, 5516 'id': self.id, 5517 'name': self.name, 5518 'secret_store_id': self.secret_store_id, 5519 'subdomain': self.subdomain, 5520 'tags': self.tags, 5521 'url': self.url, 5522 }
View Source
5524 @classmethod 5525 def from_dict(cls, d): 5526 return cls( 5527 auth_header=d.get('auth_header'), 5528 default_path=d.get('default_path'), 5529 egress_filter=d.get('egress_filter'), 5530 headers_blacklist=d.get('headers_blacklist'), 5531 healthcheck_path=d.get('healthcheck_path'), 5532 healthy=d.get('healthy'), 5533 id=d.get('id'), 5534 name=d.get('name'), 5535 secret_store_id=d.get('secret_store_id'), 5536 subdomain=d.get('subdomain'), 5537 tags=d.get('tags'), 5538 url=d.get('url'), 5539 )
View Source
5542class HTTPBasicAuth: 5543 ''' 5544 5545 ''' 5546 __slots__ = [ 5547 'default_path', 5548 'egress_filter', 5549 'headers_blacklist', 5550 'healthcheck_path', 5551 'healthy', 5552 'id', 5553 'name', 5554 'password', 5555 'secret_store_id', 5556 'subdomain', 5557 'tags', 5558 'url', 5559 'username', 5560 ] 5561 5562 def __init__( 5563 self, 5564 default_path=None, 5565 egress_filter=None, 5566 headers_blacklist=None, 5567 healthcheck_path=None, 5568 healthy=None, 5569 id=None, 5570 name=None, 5571 password=None, 5572 secret_store_id=None, 5573 subdomain=None, 5574 tags=None, 5575 url=None, 5576 username=None, 5577 ): 5578 self.default_path = default_path if default_path is not None else '' 5579 ''' 5580 5581 ''' 5582 self.egress_filter = egress_filter if egress_filter is not None else '' 5583 ''' 5584 A filter applied to the routing logic to pin datasource to nodes. 5585 ''' 5586 self.headers_blacklist = headers_blacklist if headers_blacklist is not None else '' 5587 ''' 5588 5589 ''' 5590 self.healthcheck_path = healthcheck_path if healthcheck_path is not None else '' 5591 ''' 5592 5593 ''' 5594 self.healthy = healthy if healthy is not None else False 5595 ''' 5596 True if the datasource is reachable and the credentials are valid. 5597 ''' 5598 self.id = id if id is not None else '' 5599 ''' 5600 Unique identifier of the Resource. 5601 ''' 5602 self.name = name if name is not None else '' 5603 ''' 5604 Unique human-readable name of the Resource. 5605 ''' 5606 self.password = password if password is not None else '' 5607 ''' 5608 5609 ''' 5610 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 5611 ''' 5612 ID of the secret store containing credentials for this resource, if any. 5613 ''' 5614 self.subdomain = subdomain if subdomain is not None else '' 5615 ''' 5616 5617 ''' 5618 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 5619 ''' 5620 Tags is a map of key, value pairs. 5621 ''' 5622 self.url = url if url is not None else '' 5623 ''' 5624 5625 ''' 5626 self.username = username if username is not None else '' 5627 ''' 5628 5629 ''' 5630 5631 def __repr__(self): 5632 return '<sdm.HTTPBasicAuth ' + \ 5633 'default_path: ' + repr(self.default_path) + ' ' +\ 5634 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 5635 'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\ 5636 'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\ 5637 'healthy: ' + repr(self.healthy) + ' ' +\ 5638 'id: ' + repr(self.id) + ' ' +\ 5639 'name: ' + repr(self.name) + ' ' +\ 5640 'password: ' + repr(self.password) + ' ' +\ 5641 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 5642 'subdomain: ' + repr(self.subdomain) + ' ' +\ 5643 'tags: ' + repr(self.tags) + ' ' +\ 5644 'url: ' + repr(self.url) + ' ' +\ 5645 'username: ' + repr(self.username) + ' ' +\ 5646 '>' 5647 5648 def to_dict(self): 5649 return { 5650 'default_path': self.default_path, 5651 'egress_filter': self.egress_filter, 5652 'headers_blacklist': self.headers_blacklist, 5653 'healthcheck_path': self.healthcheck_path, 5654 'healthy': self.healthy, 5655 'id': self.id, 5656 'name': self.name, 5657 'password': self.password, 5658 'secret_store_id': self.secret_store_id, 5659 'subdomain': self.subdomain, 5660 'tags': self.tags, 5661 'url': self.url, 5662 'username': self.username, 5663 } 5664 5665 @classmethod 5666 def from_dict(cls, d): 5667 return cls( 5668 default_path=d.get('default_path'), 5669 egress_filter=d.get('egress_filter'), 5670 headers_blacklist=d.get('headers_blacklist'), 5671 healthcheck_path=d.get('healthcheck_path'), 5672 healthy=d.get('healthy'), 5673 id=d.get('id'), 5674 name=d.get('name'), 5675 password=d.get('password'), 5676 secret_store_id=d.get('secret_store_id'), 5677 subdomain=d.get('subdomain'), 5678 tags=d.get('tags'), 5679 url=d.get('url'), 5680 username=d.get('username'), 5681 )
#
HTTPBasicAuth(
default_path=None,
egress_filter=None,
headers_blacklist=None,
healthcheck_path=None,
healthy=None,
id=None,
name=None,
password=None,
secret_store_id=None,
subdomain=None,
tags=None,
url=None,
username=None
)
View Source
5562 def __init__( 5563 self, 5564 default_path=None, 5565 egress_filter=None, 5566 headers_blacklist=None, 5567 healthcheck_path=None, 5568 healthy=None, 5569 id=None, 5570 name=None, 5571 password=None, 5572 secret_store_id=None, 5573 subdomain=None, 5574 tags=None, 5575 url=None, 5576 username=None, 5577 ): 5578 self.default_path = default_path if default_path is not None else '' 5579 ''' 5580 5581 ''' 5582 self.egress_filter = egress_filter if egress_filter is not None else '' 5583 ''' 5584 A filter applied to the routing logic to pin datasource to nodes. 5585 ''' 5586 self.headers_blacklist = headers_blacklist if headers_blacklist is not None else '' 5587 ''' 5588 5589 ''' 5590 self.healthcheck_path = healthcheck_path if healthcheck_path is not None else '' 5591 ''' 5592 5593 ''' 5594 self.healthy = healthy if healthy is not None else False 5595 ''' 5596 True if the datasource is reachable and the credentials are valid. 5597 ''' 5598 self.id = id if id is not None else '' 5599 ''' 5600 Unique identifier of the Resource. 5601 ''' 5602 self.name = name if name is not None else '' 5603 ''' 5604 Unique human-readable name of the Resource. 5605 ''' 5606 self.password = password if password is not None else '' 5607 ''' 5608 5609 ''' 5610 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 5611 ''' 5612 ID of the secret store containing credentials for this resource, if any. 5613 ''' 5614 self.subdomain = subdomain if subdomain is not None else '' 5615 ''' 5616 5617 ''' 5618 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 5619 ''' 5620 Tags is a map of key, value pairs. 5621 ''' 5622 self.url = url if url is not None else '' 5623 ''' 5624 5625 ''' 5626 self.username = username if username is not None else '' 5627 ''' 5628 5629 '''
#
default_path
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
headers_blacklist
#
healthcheck_path
#
healthy
True if the datasource is reachable and the credentials are valid.
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
password
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
subdomain
#
url
#
username
View Source
5648 def to_dict(self): 5649 return { 5650 'default_path': self.default_path, 5651 'egress_filter': self.egress_filter, 5652 'headers_blacklist': self.headers_blacklist, 5653 'healthcheck_path': self.healthcheck_path, 5654 'healthy': self.healthy, 5655 'id': self.id, 5656 'name': self.name, 5657 'password': self.password, 5658 'secret_store_id': self.secret_store_id, 5659 'subdomain': self.subdomain, 5660 'tags': self.tags, 5661 'url': self.url, 5662 'username': self.username, 5663 }
View Source
5665 @classmethod 5666 def from_dict(cls, d): 5667 return cls( 5668 default_path=d.get('default_path'), 5669 egress_filter=d.get('egress_filter'), 5670 headers_blacklist=d.get('headers_blacklist'), 5671 healthcheck_path=d.get('healthcheck_path'), 5672 healthy=d.get('healthy'), 5673 id=d.get('id'), 5674 name=d.get('name'), 5675 password=d.get('password'), 5676 secret_store_id=d.get('secret_store_id'), 5677 subdomain=d.get('subdomain'), 5678 tags=d.get('tags'), 5679 url=d.get('url'), 5680 username=d.get('username'), 5681 )
View Source
5684class HTTPNoAuth: 5685 ''' 5686 5687 ''' 5688 __slots__ = [ 5689 'default_path', 5690 'egress_filter', 5691 'headers_blacklist', 5692 'healthcheck_path', 5693 'healthy', 5694 'id', 5695 'name', 5696 'secret_store_id', 5697 'subdomain', 5698 'tags', 5699 'url', 5700 ] 5701 5702 def __init__( 5703 self, 5704 default_path=None, 5705 egress_filter=None, 5706 headers_blacklist=None, 5707 healthcheck_path=None, 5708 healthy=None, 5709 id=None, 5710 name=None, 5711 secret_store_id=None, 5712 subdomain=None, 5713 tags=None, 5714 url=None, 5715 ): 5716 self.default_path = default_path if default_path is not None else '' 5717 ''' 5718 5719 ''' 5720 self.egress_filter = egress_filter if egress_filter is not None else '' 5721 ''' 5722 A filter applied to the routing logic to pin datasource to nodes. 5723 ''' 5724 self.headers_blacklist = headers_blacklist if headers_blacklist is not None else '' 5725 ''' 5726 5727 ''' 5728 self.healthcheck_path = healthcheck_path if healthcheck_path is not None else '' 5729 ''' 5730 5731 ''' 5732 self.healthy = healthy if healthy is not None else False 5733 ''' 5734 True if the datasource is reachable and the credentials are valid. 5735 ''' 5736 self.id = id if id is not None else '' 5737 ''' 5738 Unique identifier of the Resource. 5739 ''' 5740 self.name = name if name is not None else '' 5741 ''' 5742 Unique human-readable name of the Resource. 5743 ''' 5744 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 5745 ''' 5746 ID of the secret store containing credentials for this resource, if any. 5747 ''' 5748 self.subdomain = subdomain if subdomain is not None else '' 5749 ''' 5750 5751 ''' 5752 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 5753 ''' 5754 Tags is a map of key, value pairs. 5755 ''' 5756 self.url = url if url is not None else '' 5757 ''' 5758 5759 ''' 5760 5761 def __repr__(self): 5762 return '<sdm.HTTPNoAuth ' + \ 5763 'default_path: ' + repr(self.default_path) + ' ' +\ 5764 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 5765 'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\ 5766 'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\ 5767 'healthy: ' + repr(self.healthy) + ' ' +\ 5768 'id: ' + repr(self.id) + ' ' +\ 5769 'name: ' + repr(self.name) + ' ' +\ 5770 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 5771 'subdomain: ' + repr(self.subdomain) + ' ' +\ 5772 'tags: ' + repr(self.tags) + ' ' +\ 5773 'url: ' + repr(self.url) + ' ' +\ 5774 '>' 5775 5776 def to_dict(self): 5777 return { 5778 'default_path': self.default_path, 5779 'egress_filter': self.egress_filter, 5780 'headers_blacklist': self.headers_blacklist, 5781 'healthcheck_path': self.healthcheck_path, 5782 'healthy': self.healthy, 5783 'id': self.id, 5784 'name': self.name, 5785 'secret_store_id': self.secret_store_id, 5786 'subdomain': self.subdomain, 5787 'tags': self.tags, 5788 'url': self.url, 5789 } 5790 5791 @classmethod 5792 def from_dict(cls, d): 5793 return cls( 5794 default_path=d.get('default_path'), 5795 egress_filter=d.get('egress_filter'), 5796 headers_blacklist=d.get('headers_blacklist'), 5797 healthcheck_path=d.get('healthcheck_path'), 5798 healthy=d.get('healthy'), 5799 id=d.get('id'), 5800 name=d.get('name'), 5801 secret_store_id=d.get('secret_store_id'), 5802 subdomain=d.get('subdomain'), 5803 tags=d.get('tags'), 5804 url=d.get('url'), 5805 )
#
HTTPNoAuth(
default_path=None,
egress_filter=None,
headers_blacklist=None,
healthcheck_path=None,
healthy=None,
id=None,
name=None,
secret_store_id=None,
subdomain=None,
tags=None,
url=None
)
View Source
5702 def __init__( 5703 self, 5704 default_path=None, 5705 egress_filter=None, 5706 headers_blacklist=None, 5707 healthcheck_path=None, 5708 healthy=None, 5709 id=None, 5710 name=None, 5711 secret_store_id=None, 5712 subdomain=None, 5713 tags=None, 5714 url=None, 5715 ): 5716 self.default_path = default_path if default_path is not None else '' 5717 ''' 5718 5719 ''' 5720 self.egress_filter = egress_filter if egress_filter is not None else '' 5721 ''' 5722 A filter applied to the routing logic to pin datasource to nodes. 5723 ''' 5724 self.headers_blacklist = headers_blacklist if headers_blacklist is not None else '' 5725 ''' 5726 5727 ''' 5728 self.healthcheck_path = healthcheck_path if healthcheck_path is not None else '' 5729 ''' 5730 5731 ''' 5732 self.healthy = healthy if healthy is not None else False 5733 ''' 5734 True if the datasource is reachable and the credentials are valid. 5735 ''' 5736 self.id = id if id is not None else '' 5737 ''' 5738 Unique identifier of the Resource. 5739 ''' 5740 self.name = name if name is not None else '' 5741 ''' 5742 Unique human-readable name of the Resource. 5743 ''' 5744 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 5745 ''' 5746 ID of the secret store containing credentials for this resource, if any. 5747 ''' 5748 self.subdomain = subdomain if subdomain is not None else '' 5749 ''' 5750 5751 ''' 5752 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 5753 ''' 5754 Tags is a map of key, value pairs. 5755 ''' 5756 self.url = url if url is not None else '' 5757 ''' 5758 5759 '''
#
default_path
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
headers_blacklist
#
healthcheck_path
#
healthy
True if the datasource is reachable and the credentials are valid.
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
subdomain
#
url
View Source
5776 def to_dict(self): 5777 return { 5778 'default_path': self.default_path, 5779 'egress_filter': self.egress_filter, 5780 'headers_blacklist': self.headers_blacklist, 5781 'healthcheck_path': self.healthcheck_path, 5782 'healthy': self.healthy, 5783 'id': self.id, 5784 'name': self.name, 5785 'secret_store_id': self.secret_store_id, 5786 'subdomain': self.subdomain, 5787 'tags': self.tags, 5788 'url': self.url, 5789 }
View Source
5791 @classmethod 5792 def from_dict(cls, d): 5793 return cls( 5794 default_path=d.get('default_path'), 5795 egress_filter=d.get('egress_filter'), 5796 headers_blacklist=d.get('headers_blacklist'), 5797 healthcheck_path=d.get('healthcheck_path'), 5798 healthy=d.get('healthy'), 5799 id=d.get('id'), 5800 name=d.get('name'), 5801 secret_store_id=d.get('secret_store_id'), 5802 subdomain=d.get('subdomain'), 5803 tags=d.get('tags'), 5804 url=d.get('url'), 5805 )
View Source
5808class Kubernetes: 5809 ''' 5810 5811 ''' 5812 __slots__ = [ 5813 'certificate_authority', 5814 'client_certificate', 5815 'client_key', 5816 'egress_filter', 5817 'healthcheck_namespace', 5818 'healthy', 5819 'hostname', 5820 'id', 5821 'name', 5822 'port', 5823 'secret_store_id', 5824 'tags', 5825 ] 5826 5827 def __init__( 5828 self, 5829 certificate_authority=None, 5830 client_certificate=None, 5831 client_key=None, 5832 egress_filter=None, 5833 healthcheck_namespace=None, 5834 healthy=None, 5835 hostname=None, 5836 id=None, 5837 name=None, 5838 port=None, 5839 secret_store_id=None, 5840 tags=None, 5841 ): 5842 self.certificate_authority = certificate_authority if certificate_authority is not None else '' 5843 ''' 5844 5845 ''' 5846 self.client_certificate = client_certificate if client_certificate is not None else '' 5847 ''' 5848 5849 ''' 5850 self.client_key = client_key if client_key is not None else '' 5851 ''' 5852 5853 ''' 5854 self.egress_filter = egress_filter if egress_filter is not None else '' 5855 ''' 5856 A filter applied to the routing logic to pin datasource to nodes. 5857 ''' 5858 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 5859 ''' 5860 The path used to check the health of your connection. Defaults to `default`. 5861 ''' 5862 self.healthy = healthy if healthy is not None else False 5863 ''' 5864 True if the datasource is reachable and the credentials are valid. 5865 ''' 5866 self.hostname = hostname if hostname is not None else '' 5867 ''' 5868 5869 ''' 5870 self.id = id if id is not None else '' 5871 ''' 5872 Unique identifier of the Resource. 5873 ''' 5874 self.name = name if name is not None else '' 5875 ''' 5876 Unique human-readable name of the Resource. 5877 ''' 5878 self.port = port if port is not None else 0 5879 ''' 5880 5881 ''' 5882 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 5883 ''' 5884 ID of the secret store containing credentials for this resource, if any. 5885 ''' 5886 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 5887 ''' 5888 Tags is a map of key, value pairs. 5889 ''' 5890 5891 def __repr__(self): 5892 return '<sdm.Kubernetes ' + \ 5893 'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\ 5894 'client_certificate: ' + repr(self.client_certificate) + ' ' +\ 5895 'client_key: ' + repr(self.client_key) + ' ' +\ 5896 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 5897 'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\ 5898 'healthy: ' + repr(self.healthy) + ' ' +\ 5899 'hostname: ' + repr(self.hostname) + ' ' +\ 5900 'id: ' + repr(self.id) + ' ' +\ 5901 'name: ' + repr(self.name) + ' ' +\ 5902 'port: ' + repr(self.port) + ' ' +\ 5903 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 5904 'tags: ' + repr(self.tags) + ' ' +\ 5905 '>' 5906 5907 def to_dict(self): 5908 return { 5909 'certificate_authority': self.certificate_authority, 5910 'client_certificate': self.client_certificate, 5911 'client_key': self.client_key, 5912 'egress_filter': self.egress_filter, 5913 'healthcheck_namespace': self.healthcheck_namespace, 5914 'healthy': self.healthy, 5915 'hostname': self.hostname, 5916 'id': self.id, 5917 'name': self.name, 5918 'port': self.port, 5919 'secret_store_id': self.secret_store_id, 5920 'tags': self.tags, 5921 } 5922 5923 @classmethod 5924 def from_dict(cls, d): 5925 return cls( 5926 certificate_authority=d.get('certificate_authority'), 5927 client_certificate=d.get('client_certificate'), 5928 client_key=d.get('client_key'), 5929 egress_filter=d.get('egress_filter'), 5930 healthcheck_namespace=d.get('healthcheck_namespace'), 5931 healthy=d.get('healthy'), 5932 hostname=d.get('hostname'), 5933 id=d.get('id'), 5934 name=d.get('name'), 5935 port=d.get('port'), 5936 secret_store_id=d.get('secret_store_id'), 5937 tags=d.get('tags'), 5938 )
#
Kubernetes(
certificate_authority=None,
client_certificate=None,
client_key=None,
egress_filter=None,
healthcheck_namespace=None,
healthy=None,
hostname=None,
id=None,
name=None,
port=None,
secret_store_id=None,
tags=None
)
View Source
5827 def __init__( 5828 self, 5829 certificate_authority=None, 5830 client_certificate=None, 5831 client_key=None, 5832 egress_filter=None, 5833 healthcheck_namespace=None, 5834 healthy=None, 5835 hostname=None, 5836 id=None, 5837 name=None, 5838 port=None, 5839 secret_store_id=None, 5840 tags=None, 5841 ): 5842 self.certificate_authority = certificate_authority if certificate_authority is not None else '' 5843 ''' 5844 5845 ''' 5846 self.client_certificate = client_certificate if client_certificate is not None else '' 5847 ''' 5848 5849 ''' 5850 self.client_key = client_key if client_key is not None else '' 5851 ''' 5852 5853 ''' 5854 self.egress_filter = egress_filter if egress_filter is not None else '' 5855 ''' 5856 A filter applied to the routing logic to pin datasource to nodes. 5857 ''' 5858 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 5859 ''' 5860 The path used to check the health of your connection. Defaults to `default`. 5861 ''' 5862 self.healthy = healthy if healthy is not None else False 5863 ''' 5864 True if the datasource is reachable and the credentials are valid. 5865 ''' 5866 self.hostname = hostname if hostname is not None else '' 5867 ''' 5868 5869 ''' 5870 self.id = id if id is not None else '' 5871 ''' 5872 Unique identifier of the Resource. 5873 ''' 5874 self.name = name if name is not None else '' 5875 ''' 5876 Unique human-readable name of the Resource. 5877 ''' 5878 self.port = port if port is not None else 0 5879 ''' 5880 5881 ''' 5882 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 5883 ''' 5884 ID of the secret store containing credentials for this resource, if any. 5885 ''' 5886 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 5887 ''' 5888 Tags is a map of key, value pairs. 5889 '''
#
client_certificate
#
client_key
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthcheck_namespace
The path used to check the health of your connection. Defaults to default.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
port
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
View Source
5907 def to_dict(self): 5908 return { 5909 'certificate_authority': self.certificate_authority, 5910 'client_certificate': self.client_certificate, 5911 'client_key': self.client_key, 5912 'egress_filter': self.egress_filter, 5913 'healthcheck_namespace': self.healthcheck_namespace, 5914 'healthy': self.healthy, 5915 'hostname': self.hostname, 5916 'id': self.id, 5917 'name': self.name, 5918 'port': self.port, 5919 'secret_store_id': self.secret_store_id, 5920 'tags': self.tags, 5921 }
View Source
5923 @classmethod 5924 def from_dict(cls, d): 5925 return cls( 5926 certificate_authority=d.get('certificate_authority'), 5927 client_certificate=d.get('client_certificate'), 5928 client_key=d.get('client_key'), 5929 egress_filter=d.get('egress_filter'), 5930 healthcheck_namespace=d.get('healthcheck_namespace'), 5931 healthy=d.get('healthy'), 5932 hostname=d.get('hostname'), 5933 id=d.get('id'), 5934 name=d.get('name'), 5935 port=d.get('port'), 5936 secret_store_id=d.get('secret_store_id'), 5937 tags=d.get('tags'), 5938 )
View Source
5941class KubernetesBasicAuth: 5942 ''' 5943 5944 ''' 5945 __slots__ = [ 5946 'egress_filter', 5947 'healthcheck_namespace', 5948 'healthy', 5949 'hostname', 5950 'id', 5951 'name', 5952 'password', 5953 'port', 5954 'secret_store_id', 5955 'tags', 5956 'username', 5957 ] 5958 5959 def __init__( 5960 self, 5961 egress_filter=None, 5962 healthcheck_namespace=None, 5963 healthy=None, 5964 hostname=None, 5965 id=None, 5966 name=None, 5967 password=None, 5968 port=None, 5969 secret_store_id=None, 5970 tags=None, 5971 username=None, 5972 ): 5973 self.egress_filter = egress_filter if egress_filter is not None else '' 5974 ''' 5975 A filter applied to the routing logic to pin datasource to nodes. 5976 ''' 5977 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 5978 ''' 5979 The path used to check the health of your connection. Defaults to `default`. 5980 ''' 5981 self.healthy = healthy if healthy is not None else False 5982 ''' 5983 True if the datasource is reachable and the credentials are valid. 5984 ''' 5985 self.hostname = hostname if hostname is not None else '' 5986 ''' 5987 5988 ''' 5989 self.id = id if id is not None else '' 5990 ''' 5991 Unique identifier of the Resource. 5992 ''' 5993 self.name = name if name is not None else '' 5994 ''' 5995 Unique human-readable name of the Resource. 5996 ''' 5997 self.password = password if password is not None else '' 5998 ''' 5999 6000 ''' 6001 self.port = port if port is not None else 0 6002 ''' 6003 6004 ''' 6005 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 6006 ''' 6007 ID of the secret store containing credentials for this resource, if any. 6008 ''' 6009 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 6010 ''' 6011 Tags is a map of key, value pairs. 6012 ''' 6013 self.username = username if username is not None else '' 6014 ''' 6015 6016 ''' 6017 6018 def __repr__(self): 6019 return '<sdm.KubernetesBasicAuth ' + \ 6020 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 6021 'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\ 6022 'healthy: ' + repr(self.healthy) + ' ' +\ 6023 'hostname: ' + repr(self.hostname) + ' ' +\ 6024 'id: ' + repr(self.id) + ' ' +\ 6025 'name: ' + repr(self.name) + ' ' +\ 6026 'password: ' + repr(self.password) + ' ' +\ 6027 'port: ' + repr(self.port) + ' ' +\ 6028 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 6029 'tags: ' + repr(self.tags) + ' ' +\ 6030 'username: ' + repr(self.username) + ' ' +\ 6031 '>' 6032 6033 def to_dict(self): 6034 return { 6035 'egress_filter': self.egress_filter, 6036 'healthcheck_namespace': self.healthcheck_namespace, 6037 'healthy': self.healthy, 6038 'hostname': self.hostname, 6039 'id': self.id, 6040 'name': self.name, 6041 'password': self.password, 6042 'port': self.port, 6043 'secret_store_id': self.secret_store_id, 6044 'tags': self.tags, 6045 'username': self.username, 6046 } 6047 6048 @classmethod 6049 def from_dict(cls, d): 6050 return cls( 6051 egress_filter=d.get('egress_filter'), 6052 healthcheck_namespace=d.get('healthcheck_namespace'), 6053 healthy=d.get('healthy'), 6054 hostname=d.get('hostname'), 6055 id=d.get('id'), 6056 name=d.get('name'), 6057 password=d.get('password'), 6058 port=d.get('port'), 6059 secret_store_id=d.get('secret_store_id'), 6060 tags=d.get('tags'), 6061 username=d.get('username'), 6062 )
#
KubernetesBasicAuth(
egress_filter=None,
healthcheck_namespace=None,
healthy=None,
hostname=None,
id=None,
name=None,
password=None,
port=None,
secret_store_id=None,
tags=None,
username=None
)
View Source
5959 def __init__( 5960 self, 5961 egress_filter=None, 5962 healthcheck_namespace=None, 5963 healthy=None, 5964 hostname=None, 5965 id=None, 5966 name=None, 5967 password=None, 5968 port=None, 5969 secret_store_id=None, 5970 tags=None, 5971 username=None, 5972 ): 5973 self.egress_filter = egress_filter if egress_filter is not None else '' 5974 ''' 5975 A filter applied to the routing logic to pin datasource to nodes. 5976 ''' 5977 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 5978 ''' 5979 The path used to check the health of your connection. Defaults to `default`. 5980 ''' 5981 self.healthy = healthy if healthy is not None else False 5982 ''' 5983 True if the datasource is reachable and the credentials are valid. 5984 ''' 5985 self.hostname = hostname if hostname is not None else '' 5986 ''' 5987 5988 ''' 5989 self.id = id if id is not None else '' 5990 ''' 5991 Unique identifier of the Resource. 5992 ''' 5993 self.name = name if name is not None else '' 5994 ''' 5995 Unique human-readable name of the Resource. 5996 ''' 5997 self.password = password if password is not None else '' 5998 ''' 5999 6000 ''' 6001 self.port = port if port is not None else 0 6002 ''' 6003 6004 ''' 6005 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 6006 ''' 6007 ID of the secret store containing credentials for this resource, if any. 6008 ''' 6009 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 6010 ''' 6011 Tags is a map of key, value pairs. 6012 ''' 6013 self.username = username if username is not None else '' 6014 ''' 6015 6016 '''
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthcheck_namespace
The path used to check the health of your connection. Defaults to default.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
password
#
port
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
username
View Source
6033 def to_dict(self): 6034 return { 6035 'egress_filter': self.egress_filter, 6036 'healthcheck_namespace': self.healthcheck_namespace, 6037 'healthy': self.healthy, 6038 'hostname': self.hostname, 6039 'id': self.id, 6040 'name': self.name, 6041 'password': self.password, 6042 'port': self.port, 6043 'secret_store_id': self.secret_store_id, 6044 'tags': self.tags, 6045 'username': self.username, 6046 }
View Source
6048 @classmethod 6049 def from_dict(cls, d): 6050 return cls( 6051 egress_filter=d.get('egress_filter'), 6052 healthcheck_namespace=d.get('healthcheck_namespace'), 6053 healthy=d.get('healthy'), 6054 hostname=d.get('hostname'), 6055 id=d.get('id'), 6056 name=d.get('name'), 6057 password=d.get('password'), 6058 port=d.get('port'), 6059 secret_store_id=d.get('secret_store_id'), 6060 tags=d.get('tags'), 6061 username=d.get('username'), 6062 )
View Source
6065class KubernetesServiceAccount: 6066 ''' 6067 6068 ''' 6069 __slots__ = [ 6070 'egress_filter', 6071 'healthcheck_namespace', 6072 'healthy', 6073 'hostname', 6074 'id', 6075 'name', 6076 'port', 6077 'secret_store_id', 6078 'tags', 6079 'token', 6080 ] 6081 6082 def __init__( 6083 self, 6084 egress_filter=None, 6085 healthcheck_namespace=None, 6086 healthy=None, 6087 hostname=None, 6088 id=None, 6089 name=None, 6090 port=None, 6091 secret_store_id=None, 6092 tags=None, 6093 token=None, 6094 ): 6095 self.egress_filter = egress_filter if egress_filter is not None else '' 6096 ''' 6097 A filter applied to the routing logic to pin datasource to nodes. 6098 ''' 6099 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 6100 ''' 6101 The path used to check the health of your connection. Defaults to `default`. 6102 ''' 6103 self.healthy = healthy if healthy is not None else False 6104 ''' 6105 True if the datasource is reachable and the credentials are valid. 6106 ''' 6107 self.hostname = hostname if hostname is not None else '' 6108 ''' 6109 6110 ''' 6111 self.id = id if id is not None else '' 6112 ''' 6113 Unique identifier of the Resource. 6114 ''' 6115 self.name = name if name is not None else '' 6116 ''' 6117 Unique human-readable name of the Resource. 6118 ''' 6119 self.port = port if port is not None else 0 6120 ''' 6121 6122 ''' 6123 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 6124 ''' 6125 ID of the secret store containing credentials for this resource, if any. 6126 ''' 6127 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 6128 ''' 6129 Tags is a map of key, value pairs. 6130 ''' 6131 self.token = token if token is not None else '' 6132 ''' 6133 6134 ''' 6135 6136 def __repr__(self): 6137 return '<sdm.KubernetesServiceAccount ' + \ 6138 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 6139 'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\ 6140 'healthy: ' + repr(self.healthy) + ' ' +\ 6141 'hostname: ' + repr(self.hostname) + ' ' +\ 6142 'id: ' + repr(self.id) + ' ' +\ 6143 'name: ' + repr(self.name) + ' ' +\ 6144 'port: ' + repr(self.port) + ' ' +\ 6145 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 6146 'tags: ' + repr(self.tags) + ' ' +\ 6147 'token: ' + repr(self.token) + ' ' +\ 6148 '>' 6149 6150 def to_dict(self): 6151 return { 6152 'egress_filter': self.egress_filter, 6153 'healthcheck_namespace': self.healthcheck_namespace, 6154 'healthy': self.healthy, 6155 'hostname': self.hostname, 6156 'id': self.id, 6157 'name': self.name, 6158 'port': self.port, 6159 'secret_store_id': self.secret_store_id, 6160 'tags': self.tags, 6161 'token': self.token, 6162 } 6163 6164 @classmethod 6165 def from_dict(cls, d): 6166 return cls( 6167 egress_filter=d.get('egress_filter'), 6168 healthcheck_namespace=d.get('healthcheck_namespace'), 6169 healthy=d.get('healthy'), 6170 hostname=d.get('hostname'), 6171 id=d.get('id'), 6172 name=d.get('name'), 6173 port=d.get('port'), 6174 secret_store_id=d.get('secret_store_id'), 6175 tags=d.get('tags'), 6176 token=d.get('token'), 6177 )
#
KubernetesServiceAccount(
egress_filter=None,
healthcheck_namespace=None,
healthy=None,
hostname=None,
id=None,
name=None,
port=None,
secret_store_id=None,
tags=None,
token=None
)
View Source
6082 def __init__( 6083 self, 6084 egress_filter=None, 6085 healthcheck_namespace=None, 6086 healthy=None, 6087 hostname=None, 6088 id=None, 6089 name=None, 6090 port=None, 6091 secret_store_id=None, 6092 tags=None, 6093 token=None, 6094 ): 6095 self.egress_filter = egress_filter if egress_filter is not None else '' 6096 ''' 6097 A filter applied to the routing logic to pin datasource to nodes. 6098 ''' 6099 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 6100 ''' 6101 The path used to check the health of your connection. Defaults to `default`. 6102 ''' 6103 self.healthy = healthy if healthy is not None else False 6104 ''' 6105 True if the datasource is reachable and the credentials are valid. 6106 ''' 6107 self.hostname = hostname if hostname is not None else '' 6108 ''' 6109 6110 ''' 6111 self.id = id if id is not None else '' 6112 ''' 6113 Unique identifier of the Resource. 6114 ''' 6115 self.name = name if name is not None else '' 6116 ''' 6117 Unique human-readable name of the Resource. 6118 ''' 6119 self.port = port if port is not None else 0 6120 ''' 6121 6122 ''' 6123 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 6124 ''' 6125 ID of the secret store containing credentials for this resource, if any. 6126 ''' 6127 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 6128 ''' 6129 Tags is a map of key, value pairs. 6130 ''' 6131 self.token = token if token is not None else '' 6132 ''' 6133 6134 '''
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthcheck_namespace
The path used to check the health of your connection. Defaults to default.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
port
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
token
View Source
6150 def to_dict(self): 6151 return { 6152 'egress_filter': self.egress_filter, 6153 'healthcheck_namespace': self.healthcheck_namespace, 6154 'healthy': self.healthy, 6155 'hostname': self.hostname, 6156 'id': self.id, 6157 'name': self.name, 6158 'port': self.port, 6159 'secret_store_id': self.secret_store_id, 6160 'tags': self.tags, 6161 'token': self.token, 6162 }
View Source
6164 @classmethod 6165 def from_dict(cls, d): 6166 return cls( 6167 egress_filter=d.get('egress_filter'), 6168 healthcheck_namespace=d.get('healthcheck_namespace'), 6169 healthy=d.get('healthy'), 6170 hostname=d.get('hostname'), 6171 id=d.get('id'), 6172 name=d.get('name'), 6173 port=d.get('port'), 6174 secret_store_id=d.get('secret_store_id'), 6175 tags=d.get('tags'), 6176 token=d.get('token'), 6177 )
View Source
6180class KubernetesServiceAccountUserImpersonation: 6181 ''' 6182 6183 ''' 6184 __slots__ = [ 6185 'egress_filter', 6186 'healthcheck_namespace', 6187 'healthy', 6188 'hostname', 6189 'id', 6190 'name', 6191 'port', 6192 'secret_store_id', 6193 'tags', 6194 'token', 6195 ] 6196 6197 def __init__( 6198 self, 6199 egress_filter=None, 6200 healthcheck_namespace=None, 6201 healthy=None, 6202 hostname=None, 6203 id=None, 6204 name=None, 6205 port=None, 6206 secret_store_id=None, 6207 tags=None, 6208 token=None, 6209 ): 6210 self.egress_filter = egress_filter if egress_filter is not None else '' 6211 ''' 6212 A filter applied to the routing logic to pin datasource to nodes. 6213 ''' 6214 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 6215 ''' 6216 The path used to check the health of your connection. Defaults to `default`. 6217 ''' 6218 self.healthy = healthy if healthy is not None else False 6219 ''' 6220 True if the datasource is reachable and the credentials are valid. 6221 ''' 6222 self.hostname = hostname if hostname is not None else '' 6223 ''' 6224 6225 ''' 6226 self.id = id if id is not None else '' 6227 ''' 6228 Unique identifier of the Resource. 6229 ''' 6230 self.name = name if name is not None else '' 6231 ''' 6232 Unique human-readable name of the Resource. 6233 ''' 6234 self.port = port if port is not None else 0 6235 ''' 6236 6237 ''' 6238 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 6239 ''' 6240 ID of the secret store containing credentials for this resource, if any. 6241 ''' 6242 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 6243 ''' 6244 Tags is a map of key, value pairs. 6245 ''' 6246 self.token = token if token is not None else '' 6247 ''' 6248 6249 ''' 6250 6251 def __repr__(self): 6252 return '<sdm.KubernetesServiceAccountUserImpersonation ' + \ 6253 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 6254 'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\ 6255 'healthy: ' + repr(self.healthy) + ' ' +\ 6256 'hostname: ' + repr(self.hostname) + ' ' +\ 6257 'id: ' + repr(self.id) + ' ' +\ 6258 'name: ' + repr(self.name) + ' ' +\ 6259 'port: ' + repr(self.port) + ' ' +\ 6260 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 6261 'tags: ' + repr(self.tags) + ' ' +\ 6262 'token: ' + repr(self.token) + ' ' +\ 6263 '>' 6264 6265 def to_dict(self): 6266 return { 6267 'egress_filter': self.egress_filter, 6268 'healthcheck_namespace': self.healthcheck_namespace, 6269 'healthy': self.healthy, 6270 'hostname': self.hostname, 6271 'id': self.id, 6272 'name': self.name, 6273 'port': self.port, 6274 'secret_store_id': self.secret_store_id, 6275 'tags': self.tags, 6276 'token': self.token, 6277 } 6278 6279 @classmethod 6280 def from_dict(cls, d): 6281 return cls( 6282 egress_filter=d.get('egress_filter'), 6283 healthcheck_namespace=d.get('healthcheck_namespace'), 6284 healthy=d.get('healthy'), 6285 hostname=d.get('hostname'), 6286 id=d.get('id'), 6287 name=d.get('name'), 6288 port=d.get('port'), 6289 secret_store_id=d.get('secret_store_id'), 6290 tags=d.get('tags'), 6291 token=d.get('token'), 6292 )
#
KubernetesServiceAccountUserImpersonation(
egress_filter=None,
healthcheck_namespace=None,
healthy=None,
hostname=None,
id=None,
name=None,
port=None,
secret_store_id=None,
tags=None,
token=None
)
View Source
6197 def __init__( 6198 self, 6199 egress_filter=None, 6200 healthcheck_namespace=None, 6201 healthy=None, 6202 hostname=None, 6203 id=None, 6204 name=None, 6205 port=None, 6206 secret_store_id=None, 6207 tags=None, 6208 token=None, 6209 ): 6210 self.egress_filter = egress_filter if egress_filter is not None else '' 6211 ''' 6212 A filter applied to the routing logic to pin datasource to nodes. 6213 ''' 6214 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 6215 ''' 6216 The path used to check the health of your connection. Defaults to `default`. 6217 ''' 6218 self.healthy = healthy if healthy is not None else False 6219 ''' 6220 True if the datasource is reachable and the credentials are valid. 6221 ''' 6222 self.hostname = hostname if hostname is not None else '' 6223 ''' 6224 6225 ''' 6226 self.id = id if id is not None else '' 6227 ''' 6228 Unique identifier of the Resource. 6229 ''' 6230 self.name = name if name is not None else '' 6231 ''' 6232 Unique human-readable name of the Resource. 6233 ''' 6234 self.port = port if port is not None else 0 6235 ''' 6236 6237 ''' 6238 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 6239 ''' 6240 ID of the secret store containing credentials for this resource, if any. 6241 ''' 6242 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 6243 ''' 6244 Tags is a map of key, value pairs. 6245 ''' 6246 self.token = token if token is not None else '' 6247 ''' 6248 6249 '''
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthcheck_namespace
The path used to check the health of your connection. Defaults to default.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
port
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
token
View Source
6265 def to_dict(self): 6266 return { 6267 'egress_filter': self.egress_filter, 6268 'healthcheck_namespace': self.healthcheck_namespace, 6269 'healthy': self.healthy, 6270 'hostname': self.hostname, 6271 'id': self.id, 6272 'name': self.name, 6273 'port': self.port, 6274 'secret_store_id': self.secret_store_id, 6275 'tags': self.tags, 6276 'token': self.token, 6277 }
View Source
6279 @classmethod 6280 def from_dict(cls, d): 6281 return cls( 6282 egress_filter=d.get('egress_filter'), 6283 healthcheck_namespace=d.get('healthcheck_namespace'), 6284 healthy=d.get('healthy'), 6285 hostname=d.get('hostname'), 6286 id=d.get('id'), 6287 name=d.get('name'), 6288 port=d.get('port'), 6289 secret_store_id=d.get('secret_store_id'), 6290 tags=d.get('tags'), 6291 token=d.get('token'), 6292 )
View Source
6295class KubernetesUserImpersonation: 6296 ''' 6297 6298 ''' 6299 __slots__ = [ 6300 'certificate_authority', 6301 'client_certificate', 6302 'client_key', 6303 'egress_filter', 6304 'healthcheck_namespace', 6305 'healthy', 6306 'hostname', 6307 'id', 6308 'name', 6309 'port', 6310 'secret_store_id', 6311 'tags', 6312 ] 6313 6314 def __init__( 6315 self, 6316 certificate_authority=None, 6317 client_certificate=None, 6318 client_key=None, 6319 egress_filter=None, 6320 healthcheck_namespace=None, 6321 healthy=None, 6322 hostname=None, 6323 id=None, 6324 name=None, 6325 port=None, 6326 secret_store_id=None, 6327 tags=None, 6328 ): 6329 self.certificate_authority = certificate_authority if certificate_authority is not None else '' 6330 ''' 6331 6332 ''' 6333 self.client_certificate = client_certificate if client_certificate is not None else '' 6334 ''' 6335 6336 ''' 6337 self.client_key = client_key if client_key is not None else '' 6338 ''' 6339 6340 ''' 6341 self.egress_filter = egress_filter if egress_filter is not None else '' 6342 ''' 6343 A filter applied to the routing logic to pin datasource to nodes. 6344 ''' 6345 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 6346 ''' 6347 The path used to check the health of your connection. Defaults to `default`. 6348 ''' 6349 self.healthy = healthy if healthy is not None else False 6350 ''' 6351 True if the datasource is reachable and the credentials are valid. 6352 ''' 6353 self.hostname = hostname if hostname is not None else '' 6354 ''' 6355 6356 ''' 6357 self.id = id if id is not None else '' 6358 ''' 6359 Unique identifier of the Resource. 6360 ''' 6361 self.name = name if name is not None else '' 6362 ''' 6363 Unique human-readable name of the Resource. 6364 ''' 6365 self.port = port if port is not None else 0 6366 ''' 6367 6368 ''' 6369 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 6370 ''' 6371 ID of the secret store containing credentials for this resource, if any. 6372 ''' 6373 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 6374 ''' 6375 Tags is a map of key, value pairs. 6376 ''' 6377 6378 def __repr__(self): 6379 return '<sdm.KubernetesUserImpersonation ' + \ 6380 'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\ 6381 'client_certificate: ' + repr(self.client_certificate) + ' ' +\ 6382 'client_key: ' + repr(self.client_key) + ' ' +\ 6383 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 6384 'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\ 6385 'healthy: ' + repr(self.healthy) + ' ' +\ 6386 'hostname: ' + repr(self.hostname) + ' ' +\ 6387 'id: ' + repr(self.id) + ' ' +\ 6388 'name: ' + repr(self.name) + ' ' +\ 6389 'port: ' + repr(self.port) + ' ' +\ 6390 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 6391 'tags: ' + repr(self.tags) + ' ' +\ 6392 '>' 6393 6394 def to_dict(self): 6395 return { 6396 'certificate_authority': self.certificate_authority, 6397 'client_certificate': self.client_certificate, 6398 'client_key': self.client_key, 6399 'egress_filter': self.egress_filter, 6400 'healthcheck_namespace': self.healthcheck_namespace, 6401 'healthy': self.healthy, 6402 'hostname': self.hostname, 6403 'id': self.id, 6404 'name': self.name, 6405 'port': self.port, 6406 'secret_store_id': self.secret_store_id, 6407 'tags': self.tags, 6408 } 6409 6410 @classmethod 6411 def from_dict(cls, d): 6412 return cls( 6413 certificate_authority=d.get('certificate_authority'), 6414 client_certificate=d.get('client_certificate'), 6415 client_key=d.get('client_key'), 6416 egress_filter=d.get('egress_filter'), 6417 healthcheck_namespace=d.get('healthcheck_namespace'), 6418 healthy=d.get('healthy'), 6419 hostname=d.get('hostname'), 6420 id=d.get('id'), 6421 name=d.get('name'), 6422 port=d.get('port'), 6423 secret_store_id=d.get('secret_store_id'), 6424 tags=d.get('tags'), 6425 )
#
KubernetesUserImpersonation(
certificate_authority=None,
client_certificate=None,
client_key=None,
egress_filter=None,
healthcheck_namespace=None,
healthy=None,
hostname=None,
id=None,
name=None,
port=None,
secret_store_id=None,
tags=None
)
View Source
6314 def __init__( 6315 self, 6316 certificate_authority=None, 6317 client_certificate=None, 6318 client_key=None, 6319 egress_filter=None, 6320 healthcheck_namespace=None, 6321 healthy=None, 6322 hostname=None, 6323 id=None, 6324 name=None, 6325 port=None, 6326 secret_store_id=None, 6327 tags=None, 6328 ): 6329 self.certificate_authority = certificate_authority if certificate_authority is not None else '' 6330 ''' 6331 6332 ''' 6333 self.client_certificate = client_certificate if client_certificate is not None else '' 6334 ''' 6335 6336 ''' 6337 self.client_key = client_key if client_key is not None else '' 6338 ''' 6339 6340 ''' 6341 self.egress_filter = egress_filter if egress_filter is not None else '' 6342 ''' 6343 A filter applied to the routing logic to pin datasource to nodes. 6344 ''' 6345 self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else '' 6346 ''' 6347 The path used to check the health of your connection. Defaults to `default`. 6348 ''' 6349 self.healthy = healthy if healthy is not None else False 6350 ''' 6351 True if the datasource is reachable and the credentials are valid. 6352 ''' 6353 self.hostname = hostname if hostname is not None else '' 6354 ''' 6355 6356 ''' 6357 self.id = id if id is not None else '' 6358 ''' 6359 Unique identifier of the Resource. 6360 ''' 6361 self.name = name if name is not None else '' 6362 ''' 6363 Unique human-readable name of the Resource. 6364 ''' 6365 self.port = port if port is not None else 0 6366 ''' 6367 6368 ''' 6369 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 6370 ''' 6371 ID of the secret store containing credentials for this resource, if any. 6372 ''' 6373 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 6374 ''' 6375 Tags is a map of key, value pairs. 6376 '''
#
client_certificate
#
client_key
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthcheck_namespace
The path used to check the health of your connection. Defaults to default.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
port
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
View Source
6394 def to_dict(self): 6395 return { 6396 'certificate_authority': self.certificate_authority, 6397 'client_certificate': self.client_certificate, 6398 'client_key': self.client_key, 6399 'egress_filter': self.egress_filter, 6400 'healthcheck_namespace': self.healthcheck_namespace, 6401 'healthy': self.healthy, 6402 'hostname': self.hostname, 6403 'id': self.id, 6404 'name': self.name, 6405 'port': self.port, 6406 'secret_store_id': self.secret_store_id, 6407 'tags': self.tags, 6408 }
View Source
6410 @classmethod 6411 def from_dict(cls, d): 6412 return cls( 6413 certificate_authority=d.get('certificate_authority'), 6414 client_certificate=d.get('client_certificate'), 6415 client_key=d.get('client_key'), 6416 egress_filter=d.get('egress_filter'), 6417 healthcheck_namespace=d.get('healthcheck_namespace'), 6418 healthy=d.get('healthy'), 6419 hostname=d.get('hostname'), 6420 id=d.get('id'), 6421 name=d.get('name'), 6422 port=d.get('port'), 6423 secret_store_id=d.get('secret_store_id'), 6424 tags=d.get('tags'), 6425 )
View Source
6428class MTLSMysql: 6429 ''' 6430 6431 ''' 6432 __slots__ = [ 6433 'certificate_authority', 6434 'client_certificate', 6435 'client_key', 6436 'database', 6437 'egress_filter', 6438 'healthy', 6439 'hostname', 6440 'id', 6441 'name', 6442 'password', 6443 'port', 6444 'port_override', 6445 'secret_store_id', 6446 'server_name', 6447 'tags', 6448 'username', 6449 ] 6450 6451 def __init__( 6452 self, 6453 certificate_authority=None, 6454 client_certificate=None, 6455 client_key=None, 6456 database=None, 6457 egress_filter=None, 6458 healthy=None, 6459 hostname=None, 6460 id=None, 6461 name=None, 6462 password=None, 6463 port=None, 6464 port_override=None, 6465 secret_store_id=None, 6466 server_name=None, 6467 tags=None, 6468 username=None, 6469 ): 6470 self.certificate_authority = certificate_authority if certificate_authority is not None else '' 6471 ''' 6472 6473 ''' 6474 self.client_certificate = client_certificate if client_certificate is not None else '' 6475 ''' 6476 6477 ''' 6478 self.client_key = client_key if client_key is not None else '' 6479 ''' 6480 6481 ''' 6482 self.database = database if database is not None else '' 6483 ''' 6484 6485 ''' 6486 self.egress_filter = egress_filter if egress_filter is not None else '' 6487 ''' 6488 A filter applied to the routing logic to pin datasource to nodes. 6489 ''' 6490 self.healthy = healthy if healthy is not None else False 6491 ''' 6492 True if the datasource is reachable and the credentials are valid. 6493 ''' 6494 self.hostname = hostname if hostname is not None else '' 6495 ''' 6496 6497 ''' 6498 self.id = id if id is not None else '' 6499 ''' 6500 Unique identifier of the Resource. 6501 ''' 6502 self.name = name if name is not None else '' 6503 ''' 6504 Unique human-readable name of the Resource. 6505 ''' 6506 self.password = password if password is not None else '' 6507 ''' 6508 6509 ''' 6510 self.port = port if port is not None else 0 6511 ''' 6512 6513 ''' 6514 self.port_override = port_override if port_override is not None else 0 6515 ''' 6516 6517 ''' 6518 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 6519 ''' 6520 ID of the secret store containing credentials for this resource, if any. 6521 ''' 6522 self.server_name = server_name if server_name is not None else '' 6523 ''' 6524 6525 ''' 6526 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 6527 ''' 6528 Tags is a map of key, value pairs. 6529 ''' 6530 self.username = username if username is not None else '' 6531 ''' 6532 6533 ''' 6534 6535 def __repr__(self): 6536 return '<sdm.MTLSMysql ' + \ 6537 'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\ 6538 'client_certificate: ' + repr(self.client_certificate) + ' ' +\ 6539 'client_key: ' + repr(self.client_key) + ' ' +\ 6540 'database: ' + repr(self.database) + ' ' +\ 6541 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 6542 'healthy: ' + repr(self.healthy) + ' ' +\ 6543 'hostname: ' + repr(self.hostname) + ' ' +\ 6544 'id: ' + repr(self.id) + ' ' +\ 6545 'name: ' + repr(self.name) + ' ' +\ 6546 'password: ' + repr(self.password) + ' ' +\ 6547 'port: ' + repr(self.port) + ' ' +\ 6548 'port_override: ' + repr(self.port_override) + ' ' +\ 6549 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 6550 'server_name: ' + repr(self.server_name) + ' ' +\ 6551 'tags: ' + repr(self.tags) + ' ' +\ 6552 'username: ' + repr(self.username) + ' ' +\ 6553 '>' 6554 6555 def to_dict(self): 6556 return { 6557 'certificate_authority': self.certificate_authority, 6558 'client_certificate': self.client_certificate, 6559 'client_key': self.client_key, 6560 'database': self.database, 6561 'egress_filter': self.egress_filter, 6562 'healthy': self.healthy, 6563 'hostname': self.hostname, 6564 'id': self.id, 6565 'name': self.name, 6566 'password': self.password, 6567 'port': self.port, 6568 'port_override': self.port_override, 6569 'secret_store_id': self.secret_store_id, 6570 'server_name': self.server_name, 6571 'tags': self.tags, 6572 'username': self.username, 6573 } 6574 6575 @classmethod 6576 def from_dict(cls, d): 6577 return cls( 6578 certificate_authority=d.get('certificate_authority'), 6579 client_certificate=d.get('client_certificate'), 6580 client_key=d.get('client_key'), 6581 database=d.get('database'), 6582 egress_filter=d.get('egress_filter'), 6583 healthy=d.get('healthy'), 6584 hostname=d.get('hostname'), 6585 id=d.get('id'), 6586 name=d.get('name'), 6587 password=d.get('password'), 6588 port=d.get('port'), 6589 port_override=d.get('port_override'), 6590 secret_store_id=d.get('secret_store_id'), 6591 server_name=d.get('server_name'), 6592 tags=d.get('tags'), 6593 username=d.get('username'), 6594 )
#
MTLSMysql(
certificate_authority=None,
client_certificate=None,
client_key=None,
database=None,
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
password=None,
port=None,
port_override=None,
secret_store_id=None,
server_name=None,
tags=None,
username=None
)
View Source
6451 def __init__( 6452 self, 6453 certificate_authority=None, 6454 client_certificate=None, 6455 client_key=None, 6456 database=None, 6457 egress_filter=None, 6458 healthy=None, 6459 hostname=None, 6460 id=None, 6461 name=None, 6462 password=None, 6463 port=None, 6464 port_override=None, 6465 secret_store_id=None, 6466 server_name=None, 6467 tags=None, 6468 username=None, 6469 ): 6470 self.certificate_authority = certificate_authority if certificate_authority is not None else '' 6471 ''' 6472 6473 ''' 6474 self.client_certificate = client_certificate if client_certificate is not None else '' 6475 ''' 6476 6477 ''' 6478 self.client_key = client_key if client_key is not None else '' 6479 ''' 6480 6481 ''' 6482 self.database = database if database is not None else '' 6483 ''' 6484 6485 ''' 6486 self.egress_filter = egress_filter if egress_filter is not None else '' 6487 ''' 6488 A filter applied to the routing logic to pin datasource to nodes. 6489 ''' 6490 self.healthy = healthy if healthy is not None else False 6491 ''' 6492 True if the datasource is reachable and the credentials are valid. 6493 ''' 6494 self.hostname = hostname if hostname is not None else '' 6495 ''' 6496 6497 ''' 6498 self.id = id if id is not None else '' 6499 ''' 6500 Unique identifier of the Resource. 6501 ''' 6502 self.name = name if name is not None else '' 6503 ''' 6504 Unique human-readable name of the Resource. 6505 ''' 6506 self.password = password if password is not None else '' 6507 ''' 6508 6509 ''' 6510 self.port = port if port is not None else 0 6511 ''' 6512 6513 ''' 6514 self.port_override = port_override if port_override is not None else 0 6515 ''' 6516 6517 ''' 6518 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 6519 ''' 6520 ID of the secret store containing credentials for this resource, if any. 6521 ''' 6522 self.server_name = server_name if server_name is not None else '' 6523 ''' 6524 6525 ''' 6526 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 6527 ''' 6528 Tags is a map of key, value pairs. 6529 ''' 6530 self.username = username if username is not None else '' 6531 ''' 6532 6533 '''
#
client_certificate
#
client_key
#
database
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
password
#
port
#
port_override
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
server_name
#
username
View Source
6555 def to_dict(self): 6556 return { 6557 'certificate_authority': self.certificate_authority, 6558 'client_certificate': self.client_certificate, 6559 'client_key': self.client_key, 6560 'database': self.database, 6561 'egress_filter': self.egress_filter, 6562 'healthy': self.healthy, 6563 'hostname': self.hostname, 6564 'id': self.id, 6565 'name': self.name, 6566 'password': self.password, 6567 'port': self.port, 6568 'port_override': self.port_override, 6569 'secret_store_id': self.secret_store_id, 6570 'server_name': self.server_name, 6571 'tags': self.tags, 6572 'username': self.username, 6573 }
View Source
6575 @classmethod 6576 def from_dict(cls, d): 6577 return cls( 6578 certificate_authority=d.get('certificate_authority'), 6579 client_certificate=d.get('client_certificate'), 6580 client_key=d.get('client_key'), 6581 database=d.get('database'), 6582 egress_filter=d.get('egress_filter'), 6583 healthy=d.get('healthy'), 6584 hostname=d.get('hostname'), 6585 id=d.get('id'), 6586 name=d.get('name'), 6587 password=d.get('password'), 6588 port=d.get('port'), 6589 port_override=d.get('port_override'), 6590 secret_store_id=d.get('secret_store_id'), 6591 server_name=d.get('server_name'), 6592 tags=d.get('tags'), 6593 username=d.get('username'), 6594 )
View Source
6597class MTLSPostgres: 6598 ''' 6599 6600 ''' 6601 __slots__ = [ 6602 'certificate_authority', 6603 'client_certificate', 6604 'client_key', 6605 'database', 6606 'egress_filter', 6607 'healthy', 6608 'hostname', 6609 'id', 6610 'name', 6611 'override_database', 6612 'password', 6613 'port', 6614 'port_override', 6615 'secret_store_id', 6616 'server_name', 6617 'tags', 6618 'username', 6619 ] 6620 6621 def __init__( 6622 self, 6623 certificate_authority=None, 6624 client_certificate=None, 6625 client_key=None, 6626 database=None, 6627 egress_filter=None, 6628 healthy=None, 6629 hostname=None, 6630 id=None, 6631 name=None, 6632 override_database=None, 6633 password=None, 6634 port=None, 6635 port_override=None, 6636 secret_store_id=None, 6637 server_name=None, 6638 tags=None, 6639 username=None, 6640 ): 6641 self.certificate_authority = certificate_authority if certificate_authority is not None else '' 6642 ''' 6643 6644 ''' 6645 self.client_certificate = client_certificate if client_certificate is not None else '' 6646 ''' 6647 6648 ''' 6649 self.client_key = client_key if client_key is not None else '' 6650 ''' 6651 6652 ''' 6653 self.database = database if database is not None else '' 6654 ''' 6655 6656 ''' 6657 self.egress_filter = egress_filter if egress_filter is not None else '' 6658 ''' 6659 A filter applied to the routing logic to pin datasource to nodes. 6660 ''' 6661 self.healthy = healthy if healthy is not None else False 6662 ''' 6663 True if the datasource is reachable and the credentials are valid. 6664 ''' 6665 self.hostname = hostname if hostname is not None else '' 6666 ''' 6667 6668 ''' 6669 self.id = id if id is not None else '' 6670 ''' 6671 Unique identifier of the Resource. 6672 ''' 6673 self.name = name if name is not None else '' 6674 ''' 6675 Unique human-readable name of the Resource. 6676 ''' 6677 self.override_database = override_database if override_database is not None else False 6678 ''' 6679 6680 ''' 6681 self.password = password if password is not None else '' 6682 ''' 6683 6684 ''' 6685 self.port = port if port is not None else 0 6686 ''' 6687 6688 ''' 6689 self.port_override = port_override if port_override is not None else 0 6690 ''' 6691 6692 ''' 6693 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 6694 ''' 6695 ID of the secret store containing credentials for this resource, if any. 6696 ''' 6697 self.server_name = server_name if server_name is not None else '' 6698 ''' 6699 6700 ''' 6701 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 6702 ''' 6703 Tags is a map of key, value pairs. 6704 ''' 6705 self.username = username if username is not None else '' 6706 ''' 6707 6708 ''' 6709 6710 def __repr__(self): 6711 return '<sdm.MTLSPostgres ' + \ 6712 'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\ 6713 'client_certificate: ' + repr(self.client_certificate) + ' ' +\ 6714 'client_key: ' + repr(self.client_key) + ' ' +\ 6715 'database: ' + repr(self.database) + ' ' +\ 6716 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 6717 'healthy: ' + repr(self.healthy) + ' ' +\ 6718 'hostname: ' + repr(self.hostname) + ' ' +\ 6719 'id: ' + repr(self.id) + ' ' +\ 6720 'name: ' + repr(self.name) + ' ' +\ 6721 'override_database: ' + repr(self.override_database) + ' ' +\ 6722 'password: ' + repr(self.password) + ' ' +\ 6723 'port: ' + repr(self.port) + ' ' +\ 6724 'port_override: ' + repr(self.port_override) + ' ' +\ 6725 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 6726 'server_name: ' + repr(self.server_name) + ' ' +\ 6727 'tags: ' + repr(self.tags) + ' ' +\ 6728 'username: ' + repr(self.username) + ' ' +\ 6729 '>' 6730 6731 def to_dict(self): 6732 return { 6733 'certificate_authority': self.certificate_authority, 6734 'client_certificate': self.client_certificate, 6735 'client_key': self.client_key, 6736 'database': self.database, 6737 'egress_filter': self.egress_filter, 6738 'healthy': self.healthy, 6739 'hostname': self.hostname, 6740 'id': self.id, 6741 'name': self.name, 6742 'override_database': self.override_database, 6743 'password': self.password, 6744 'port': self.port, 6745 'port_override': self.port_override, 6746 'secret_store_id': self.secret_store_id, 6747 'server_name': self.server_name, 6748 'tags': self.tags, 6749 'username': self.username, 6750 } 6751 6752 @classmethod 6753 def from_dict(cls, d): 6754 return cls( 6755 certificate_authority=d.get('certificate_authority'), 6756 client_certificate=d.get('client_certificate'), 6757 client_key=d.get('client_key'), 6758 database=d.get('database'), 6759 egress_filter=d.get('egress_filter'), 6760 healthy=d.get('healthy'), 6761 hostname=d.get('hostname'), 6762 id=d.get('id'), 6763 name=d.get('name'), 6764 override_database=d.get('override_database'), 6765 password=d.get('password'), 6766 port=d.get('port'), 6767 port_override=d.get('port_override'), 6768 secret_store_id=d.get('secret_store_id'), 6769 server_name=d.get('server_name'), 6770 tags=d.get('tags'), 6771 username=d.get('username'), 6772 )
#
MTLSPostgres(
certificate_authority=None,
client_certificate=None,
client_key=None,
database=None,
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
override_database=None,
password=None,
port=None,
port_override=None,
secret_store_id=None,
server_name=None,
tags=None,
username=None
)
View Source
6621 def __init__( 6622 self, 6623 certificate_authority=None, 6624 client_certificate=None, 6625 client_key=None, 6626 database=None, 6627 egress_filter=None, 6628 healthy=None, 6629 hostname=None, 6630 id=None, 6631 name=None, 6632 override_database=None, 6633 password=None, 6634 port=None, 6635 port_override=None, 6636 secret_store_id=None, 6637 server_name=None, 6638 tags=None, 6639 username=None, 6640 ): 6641 self.certificate_authority = certificate_authority if certificate_authority is not None else '' 6642 ''' 6643 6644 ''' 6645 self.client_certificate = client_certificate if client_certificate is not None else '' 6646 ''' 6647 6648 ''' 6649 self.client_key = client_key if client_key is not None else '' 6650 ''' 6651 6652 ''' 6653 self.database = database if database is not None else '' 6654 ''' 6655 6656 ''' 6657 self.egress_filter = egress_filter if egress_filter is not None else '' 6658 ''' 6659 A filter applied to the routing logic to pin datasource to nodes. 6660 ''' 6661 self.healthy = healthy if healthy is not None else False 6662 ''' 6663 True if the datasource is reachable and the credentials are valid. 6664 ''' 6665 self.hostname = hostname if hostname is not None else '' 6666 ''' 6667 6668 ''' 6669 self.id = id if id is not None else '' 6670 ''' 6671 Unique identifier of the Resource. 6672 ''' 6673 self.name = name if name is not None else '' 6674 ''' 6675 Unique human-readable name of the Resource. 6676 ''' 6677 self.override_database = override_database if override_database is not None else False 6678 ''' 6679 6680 ''' 6681 self.password = password if password is not None else '' 6682 ''' 6683 6684 ''' 6685 self.port = port if port is not None else 0 6686 ''' 6687 6688 ''' 6689 self.port_override = port_override if port_override is not None else 0 6690 ''' 6691 6692 ''' 6693 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 6694 ''' 6695 ID of the secret store containing credentials for this resource, if any. 6696 ''' 6697 self.server_name = server_name if server_name is not None else '' 6698 ''' 6699 6700 ''' 6701 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 6702 ''' 6703 Tags is a map of key, value pairs. 6704 ''' 6705 self.username = username if username is not None else '' 6706 ''' 6707 6708 '''
#
client_certificate
#
client_key
#
database
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
override_database
#
password
#
port
#
port_override
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
server_name
#
username
View Source
6731 def to_dict(self): 6732 return { 6733 'certificate_authority': self.certificate_authority, 6734 'client_certificate': self.client_certificate, 6735 'client_key': self.client_key, 6736 'database': self.database, 6737 'egress_filter': self.egress_filter, 6738 'healthy': self.healthy, 6739 'hostname': self.hostname, 6740 'id': self.id, 6741 'name': self.name, 6742 'override_database': self.override_database, 6743 'password': self.password, 6744 'port': self.port, 6745 'port_override': self.port_override, 6746 'secret_store_id': self.secret_store_id, 6747 'server_name': self.server_name, 6748 'tags': self.tags, 6749 'username': self.username, 6750 }
View Source
6752 @classmethod 6753 def from_dict(cls, d): 6754 return cls( 6755 certificate_authority=d.get('certificate_authority'), 6756 client_certificate=d.get('client_certificate'), 6757 client_key=d.get('client_key'), 6758 database=d.get('database'), 6759 egress_filter=d.get('egress_filter'), 6760 healthy=d.get('healthy'), 6761 hostname=d.get('hostname'), 6762 id=d.get('id'), 6763 name=d.get('name'), 6764 override_database=d.get('override_database'), 6765 password=d.get('password'), 6766 port=d.get('port'), 6767 port_override=d.get('port_override'), 6768 secret_store_id=d.get('secret_store_id'), 6769 server_name=d.get('server_name'), 6770 tags=d.get('tags'), 6771 username=d.get('username'), 6772 )
View Source
6775class Maria: 6776 ''' 6777 6778 ''' 6779 __slots__ = [ 6780 'database', 6781 'egress_filter', 6782 'healthy', 6783 'hostname', 6784 'id', 6785 'name', 6786 'password', 6787 'port', 6788 'port_override', 6789 'secret_store_id', 6790 'tags', 6791 'username', 6792 ] 6793 6794 def __init__( 6795 self, 6796 database=None, 6797 egress_filter=None, 6798 healthy=None, 6799 hostname=None, 6800 id=None, 6801 name=None, 6802 password=None, 6803 port=None, 6804 port_override=None, 6805 secret_store_id=None, 6806 tags=None, 6807 username=None, 6808 ): 6809 self.database = database if database is not None else '' 6810 ''' 6811 6812 ''' 6813 self.egress_filter = egress_filter if egress_filter is not None else '' 6814 ''' 6815 A filter applied to the routing logic to pin datasource to nodes. 6816 ''' 6817 self.healthy = healthy if healthy is not None else False 6818 ''' 6819 True if the datasource is reachable and the credentials are valid. 6820 ''' 6821 self.hostname = hostname if hostname is not None else '' 6822 ''' 6823 6824 ''' 6825 self.id = id if id is not None else '' 6826 ''' 6827 Unique identifier of the Resource. 6828 ''' 6829 self.name = name if name is not None else '' 6830 ''' 6831 Unique human-readable name of the Resource. 6832 ''' 6833 self.password = password if password is not None else '' 6834 ''' 6835 6836 ''' 6837 self.port = port if port is not None else 0 6838 ''' 6839 6840 ''' 6841 self.port_override = port_override if port_override is not None else 0 6842 ''' 6843 6844 ''' 6845 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 6846 ''' 6847 ID of the secret store containing credentials for this resource, if any. 6848 ''' 6849 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 6850 ''' 6851 Tags is a map of key, value pairs. 6852 ''' 6853 self.username = username if username is not None else '' 6854 ''' 6855 6856 ''' 6857 6858 def __repr__(self): 6859 return '<sdm.Maria ' + \ 6860 'database: ' + repr(self.database) + ' ' +\ 6861 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 6862 'healthy: ' + repr(self.healthy) + ' ' +\ 6863 'hostname: ' + repr(self.hostname) + ' ' +\ 6864 'id: ' + repr(self.id) + ' ' +\ 6865 'name: ' + repr(self.name) + ' ' +\ 6866 'password: ' + repr(self.password) + ' ' +\ 6867 'port: ' + repr(self.port) + ' ' +\ 6868 'port_override: ' + repr(self.port_override) + ' ' +\ 6869 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 6870 'tags: ' + repr(self.tags) + ' ' +\ 6871 'username: ' + repr(self.username) + ' ' +\ 6872 '>' 6873 6874 def to_dict(self): 6875 return { 6876 'database': self.database, 6877 'egress_filter': self.egress_filter, 6878 'healthy': self.healthy, 6879 'hostname': self.hostname, 6880 'id': self.id, 6881 'name': self.name, 6882 'password': self.password, 6883 'port': self.port, 6884 'port_override': self.port_override, 6885 'secret_store_id': self.secret_store_id, 6886 'tags': self.tags, 6887 'username': self.username, 6888 } 6889 6890 @classmethod 6891 def from_dict(cls, d): 6892 return cls( 6893 database=d.get('database'), 6894 egress_filter=d.get('egress_filter'), 6895 healthy=d.get('healthy'), 6896 hostname=d.get('hostname'), 6897 id=d.get('id'), 6898 name=d.get('name'), 6899 password=d.get('password'), 6900 port=d.get('port'), 6901 port_override=d.get('port_override'), 6902 secret_store_id=d.get('secret_store_id'), 6903 tags=d.get('tags'), 6904 username=d.get('username'), 6905 )
#
Maria(
database=None,
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
password=None,
port=None,
port_override=None,
secret_store_id=None,
tags=None,
username=None
)
View Source
6794 def __init__( 6795 self, 6796 database=None, 6797 egress_filter=None, 6798 healthy=None, 6799 hostname=None, 6800 id=None, 6801 name=None, 6802 password=None, 6803 port=None, 6804 port_override=None, 6805 secret_store_id=None, 6806 tags=None, 6807 username=None, 6808 ): 6809 self.database = database if database is not None else '' 6810 ''' 6811 6812 ''' 6813 self.egress_filter = egress_filter if egress_filter is not None else '' 6814 ''' 6815 A filter applied to the routing logic to pin datasource to nodes. 6816 ''' 6817 self.healthy = healthy if healthy is not None else False 6818 ''' 6819 True if the datasource is reachable and the credentials are valid. 6820 ''' 6821 self.hostname = hostname if hostname is not None else '' 6822 ''' 6823 6824 ''' 6825 self.id = id if id is not None else '' 6826 ''' 6827 Unique identifier of the Resource. 6828 ''' 6829 self.name = name if name is not None else '' 6830 ''' 6831 Unique human-readable name of the Resource. 6832 ''' 6833 self.password = password if password is not None else '' 6834 ''' 6835 6836 ''' 6837 self.port = port if port is not None else 0 6838 ''' 6839 6840 ''' 6841 self.port_override = port_override if port_override is not None else 0 6842 ''' 6843 6844 ''' 6845 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 6846 ''' 6847 ID of the secret store containing credentials for this resource, if any. 6848 ''' 6849 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 6850 ''' 6851 Tags is a map of key, value pairs. 6852 ''' 6853 self.username = username if username is not None else '' 6854 ''' 6855 6856 '''
#
database
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
password
#
port
#
port_override
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
username
View Source
6874 def to_dict(self): 6875 return { 6876 'database': self.database, 6877 'egress_filter': self.egress_filter, 6878 'healthy': self.healthy, 6879 'hostname': self.hostname, 6880 'id': self.id, 6881 'name': self.name, 6882 'password': self.password, 6883 'port': self.port, 6884 'port_override': self.port_override, 6885 'secret_store_id': self.secret_store_id, 6886 'tags': self.tags, 6887 'username': self.username, 6888 }
View Source
6890 @classmethod 6891 def from_dict(cls, d): 6892 return cls( 6893 database=d.get('database'), 6894 egress_filter=d.get('egress_filter'), 6895 healthy=d.get('healthy'), 6896 hostname=d.get('hostname'), 6897 id=d.get('id'), 6898 name=d.get('name'), 6899 password=d.get('password'), 6900 port=d.get('port'), 6901 port_override=d.get('port_override'), 6902 secret_store_id=d.get('secret_store_id'), 6903 tags=d.get('tags'), 6904 username=d.get('username'), 6905 )
View Source
6908class Memcached: 6909 ''' 6910 6911 ''' 6912 __slots__ = [ 6913 'egress_filter', 6914 'healthy', 6915 'hostname', 6916 'id', 6917 'name', 6918 'port', 6919 'port_override', 6920 'secret_store_id', 6921 'tags', 6922 ] 6923 6924 def __init__( 6925 self, 6926 egress_filter=None, 6927 healthy=None, 6928 hostname=None, 6929 id=None, 6930 name=None, 6931 port=None, 6932 port_override=None, 6933 secret_store_id=None, 6934 tags=None, 6935 ): 6936 self.egress_filter = egress_filter if egress_filter is not None else '' 6937 ''' 6938 A filter applied to the routing logic to pin datasource to nodes. 6939 ''' 6940 self.healthy = healthy if healthy is not None else False 6941 ''' 6942 True if the datasource is reachable and the credentials are valid. 6943 ''' 6944 self.hostname = hostname if hostname is not None else '' 6945 ''' 6946 6947 ''' 6948 self.id = id if id is not None else '' 6949 ''' 6950 Unique identifier of the Resource. 6951 ''' 6952 self.name = name if name is not None else '' 6953 ''' 6954 Unique human-readable name of the Resource. 6955 ''' 6956 self.port = port if port is not None else 0 6957 ''' 6958 6959 ''' 6960 self.port_override = port_override if port_override is not None else 0 6961 ''' 6962 6963 ''' 6964 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 6965 ''' 6966 ID of the secret store containing credentials for this resource, if any. 6967 ''' 6968 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 6969 ''' 6970 Tags is a map of key, value pairs. 6971 ''' 6972 6973 def __repr__(self): 6974 return '<sdm.Memcached ' + \ 6975 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 6976 'healthy: ' + repr(self.healthy) + ' ' +\ 6977 'hostname: ' + repr(self.hostname) + ' ' +\ 6978 'id: ' + repr(self.id) + ' ' +\ 6979 'name: ' + repr(self.name) + ' ' +\ 6980 'port: ' + repr(self.port) + ' ' +\ 6981 'port_override: ' + repr(self.port_override) + ' ' +\ 6982 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 6983 'tags: ' + repr(self.tags) + ' ' +\ 6984 '>' 6985 6986 def to_dict(self): 6987 return { 6988 'egress_filter': self.egress_filter, 6989 'healthy': self.healthy, 6990 'hostname': self.hostname, 6991 'id': self.id, 6992 'name': self.name, 6993 'port': self.port, 6994 'port_override': self.port_override, 6995 'secret_store_id': self.secret_store_id, 6996 'tags': self.tags, 6997 } 6998 6999 @classmethod 7000 def from_dict(cls, d): 7001 return cls( 7002 egress_filter=d.get('egress_filter'), 7003 healthy=d.get('healthy'), 7004 hostname=d.get('hostname'), 7005 id=d.get('id'), 7006 name=d.get('name'), 7007 port=d.get('port'), 7008 port_override=d.get('port_override'), 7009 secret_store_id=d.get('secret_store_id'), 7010 tags=d.get('tags'), 7011 )
#
Memcached(
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
port=None,
port_override=None,
secret_store_id=None,
tags=None
)
View Source
6924 def __init__( 6925 self, 6926 egress_filter=None, 6927 healthy=None, 6928 hostname=None, 6929 id=None, 6930 name=None, 6931 port=None, 6932 port_override=None, 6933 secret_store_id=None, 6934 tags=None, 6935 ): 6936 self.egress_filter = egress_filter if egress_filter is not None else '' 6937 ''' 6938 A filter applied to the routing logic to pin datasource to nodes. 6939 ''' 6940 self.healthy = healthy if healthy is not None else False 6941 ''' 6942 True if the datasource is reachable and the credentials are valid. 6943 ''' 6944 self.hostname = hostname if hostname is not None else '' 6945 ''' 6946 6947 ''' 6948 self.id = id if id is not None else '' 6949 ''' 6950 Unique identifier of the Resource. 6951 ''' 6952 self.name = name if name is not None else '' 6953 ''' 6954 Unique human-readable name of the Resource. 6955 ''' 6956 self.port = port if port is not None else 0 6957 ''' 6958 6959 ''' 6960 self.port_override = port_override if port_override is not None else 0 6961 ''' 6962 6963 ''' 6964 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 6965 ''' 6966 ID of the secret store containing credentials for this resource, if any. 6967 ''' 6968 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 6969 ''' 6970 Tags is a map of key, value pairs. 6971 '''
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
port
#
port_override
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
View Source
6986 def to_dict(self): 6987 return { 6988 'egress_filter': self.egress_filter, 6989 'healthy': self.healthy, 6990 'hostname': self.hostname, 6991 'id': self.id, 6992 'name': self.name, 6993 'port': self.port, 6994 'port_override': self.port_override, 6995 'secret_store_id': self.secret_store_id, 6996 'tags': self.tags, 6997 }
View Source
6999 @classmethod 7000 def from_dict(cls, d): 7001 return cls( 7002 egress_filter=d.get('egress_filter'), 7003 healthy=d.get('healthy'), 7004 hostname=d.get('hostname'), 7005 id=d.get('id'), 7006 name=d.get('name'), 7007 port=d.get('port'), 7008 port_override=d.get('port_override'), 7009 secret_store_id=d.get('secret_store_id'), 7010 tags=d.get('tags'), 7011 )
View Source
7014class Memsql: 7015 ''' 7016 7017 ''' 7018 __slots__ = [ 7019 'database', 7020 'egress_filter', 7021 'healthy', 7022 'hostname', 7023 'id', 7024 'name', 7025 'password', 7026 'port', 7027 'port_override', 7028 'secret_store_id', 7029 'tags', 7030 'username', 7031 ] 7032 7033 def __init__( 7034 self, 7035 database=None, 7036 egress_filter=None, 7037 healthy=None, 7038 hostname=None, 7039 id=None, 7040 name=None, 7041 password=None, 7042 port=None, 7043 port_override=None, 7044 secret_store_id=None, 7045 tags=None, 7046 username=None, 7047 ): 7048 self.database = database if database is not None else '' 7049 ''' 7050 7051 ''' 7052 self.egress_filter = egress_filter if egress_filter is not None else '' 7053 ''' 7054 A filter applied to the routing logic to pin datasource to nodes. 7055 ''' 7056 self.healthy = healthy if healthy is not None else False 7057 ''' 7058 True if the datasource is reachable and the credentials are valid. 7059 ''' 7060 self.hostname = hostname if hostname is not None else '' 7061 ''' 7062 7063 ''' 7064 self.id = id if id is not None else '' 7065 ''' 7066 Unique identifier of the Resource. 7067 ''' 7068 self.name = name if name is not None else '' 7069 ''' 7070 Unique human-readable name of the Resource. 7071 ''' 7072 self.password = password if password is not None else '' 7073 ''' 7074 7075 ''' 7076 self.port = port if port is not None else 0 7077 ''' 7078 7079 ''' 7080 self.port_override = port_override if port_override is not None else 0 7081 ''' 7082 7083 ''' 7084 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 7085 ''' 7086 ID of the secret store containing credentials for this resource, if any. 7087 ''' 7088 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 7089 ''' 7090 Tags is a map of key, value pairs. 7091 ''' 7092 self.username = username if username is not None else '' 7093 ''' 7094 7095 ''' 7096 7097 def __repr__(self): 7098 return '<sdm.Memsql ' + \ 7099 'database: ' + repr(self.database) + ' ' +\ 7100 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 7101 'healthy: ' + repr(self.healthy) + ' ' +\ 7102 'hostname: ' + repr(self.hostname) + ' ' +\ 7103 'id: ' + repr(self.id) + ' ' +\ 7104 'name: ' + repr(self.name) + ' ' +\ 7105 'password: ' + repr(self.password) + ' ' +\ 7106 'port: ' + repr(self.port) + ' ' +\ 7107 'port_override: ' + repr(self.port_override) + ' ' +\ 7108 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 7109 'tags: ' + repr(self.tags) + ' ' +\ 7110 'username: ' + repr(self.username) + ' ' +\ 7111 '>' 7112 7113 def to_dict(self): 7114 return { 7115 'database': self.database, 7116 'egress_filter': self.egress_filter, 7117 'healthy': self.healthy, 7118 'hostname': self.hostname, 7119 'id': self.id, 7120 'name': self.name, 7121 'password': self.password, 7122 'port': self.port, 7123 'port_override': self.port_override, 7124 'secret_store_id': self.secret_store_id, 7125 'tags': self.tags, 7126 'username': self.username, 7127 } 7128 7129 @classmethod 7130 def from_dict(cls, d): 7131 return cls( 7132 database=d.get('database'), 7133 egress_filter=d.get('egress_filter'), 7134 healthy=d.get('healthy'), 7135 hostname=d.get('hostname'), 7136 id=d.get('id'), 7137 name=d.get('name'), 7138 password=d.get('password'), 7139 port=d.get('port'), 7140 port_override=d.get('port_override'), 7141 secret_store_id=d.get('secret_store_id'), 7142 tags=d.get('tags'), 7143 username=d.get('username'), 7144 )
#
Memsql(
database=None,
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
password=None,
port=None,
port_override=None,
secret_store_id=None,
tags=None,
username=None
)
View Source
7033 def __init__( 7034 self, 7035 database=None, 7036 egress_filter=None, 7037 healthy=None, 7038 hostname=None, 7039 id=None, 7040 name=None, 7041 password=None, 7042 port=None, 7043 port_override=None, 7044 secret_store_id=None, 7045 tags=None, 7046 username=None, 7047 ): 7048 self.database = database if database is not None else '' 7049 ''' 7050 7051 ''' 7052 self.egress_filter = egress_filter if egress_filter is not None else '' 7053 ''' 7054 A filter applied to the routing logic to pin datasource to nodes. 7055 ''' 7056 self.healthy = healthy if healthy is not None else False 7057 ''' 7058 True if the datasource is reachable and the credentials are valid. 7059 ''' 7060 self.hostname = hostname if hostname is not None else '' 7061 ''' 7062 7063 ''' 7064 self.id = id if id is not None else '' 7065 ''' 7066 Unique identifier of the Resource. 7067 ''' 7068 self.name = name if name is not None else '' 7069 ''' 7070 Unique human-readable name of the Resource. 7071 ''' 7072 self.password = password if password is not None else '' 7073 ''' 7074 7075 ''' 7076 self.port = port if port is not None else 0 7077 ''' 7078 7079 ''' 7080 self.port_override = port_override if port_override is not None else 0 7081 ''' 7082 7083 ''' 7084 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 7085 ''' 7086 ID of the secret store containing credentials for this resource, if any. 7087 ''' 7088 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 7089 ''' 7090 Tags is a map of key, value pairs. 7091 ''' 7092 self.username = username if username is not None else '' 7093 ''' 7094 7095 '''
#
database
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
password
#
port
#
port_override
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
username
View Source
7113 def to_dict(self): 7114 return { 7115 'database': self.database, 7116 'egress_filter': self.egress_filter, 7117 'healthy': self.healthy, 7118 'hostname': self.hostname, 7119 'id': self.id, 7120 'name': self.name, 7121 'password': self.password, 7122 'port': self.port, 7123 'port_override': self.port_override, 7124 'secret_store_id': self.secret_store_id, 7125 'tags': self.tags, 7126 'username': self.username, 7127 }
View Source
7129 @classmethod 7130 def from_dict(cls, d): 7131 return cls( 7132 database=d.get('database'), 7133 egress_filter=d.get('egress_filter'), 7134 healthy=d.get('healthy'), 7135 hostname=d.get('hostname'), 7136 id=d.get('id'), 7137 name=d.get('name'), 7138 password=d.get('password'), 7139 port=d.get('port'), 7140 port_override=d.get('port_override'), 7141 secret_store_id=d.get('secret_store_id'), 7142 tags=d.get('tags'), 7143 username=d.get('username'), 7144 )
View Source
7147class MongoHost: 7148 ''' 7149 7150 ''' 7151 __slots__ = [ 7152 'auth_database', 7153 'egress_filter', 7154 'healthy', 7155 'hostname', 7156 'id', 7157 'name', 7158 'password', 7159 'port', 7160 'port_override', 7161 'secret_store_id', 7162 'tags', 7163 'tls_required', 7164 'username', 7165 ] 7166 7167 def __init__( 7168 self, 7169 auth_database=None, 7170 egress_filter=None, 7171 healthy=None, 7172 hostname=None, 7173 id=None, 7174 name=None, 7175 password=None, 7176 port=None, 7177 port_override=None, 7178 secret_store_id=None, 7179 tags=None, 7180 tls_required=None, 7181 username=None, 7182 ): 7183 self.auth_database = auth_database if auth_database is not None else '' 7184 ''' 7185 7186 ''' 7187 self.egress_filter = egress_filter if egress_filter is not None else '' 7188 ''' 7189 A filter applied to the routing logic to pin datasource to nodes. 7190 ''' 7191 self.healthy = healthy if healthy is not None else False 7192 ''' 7193 True if the datasource is reachable and the credentials are valid. 7194 ''' 7195 self.hostname = hostname if hostname is not None else '' 7196 ''' 7197 7198 ''' 7199 self.id = id if id is not None else '' 7200 ''' 7201 Unique identifier of the Resource. 7202 ''' 7203 self.name = name if name is not None else '' 7204 ''' 7205 Unique human-readable name of the Resource. 7206 ''' 7207 self.password = password if password is not None else '' 7208 ''' 7209 7210 ''' 7211 self.port = port if port is not None else 0 7212 ''' 7213 7214 ''' 7215 self.port_override = port_override if port_override is not None else 0 7216 ''' 7217 7218 ''' 7219 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 7220 ''' 7221 ID of the secret store containing credentials for this resource, if any. 7222 ''' 7223 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 7224 ''' 7225 Tags is a map of key, value pairs. 7226 ''' 7227 self.tls_required = tls_required if tls_required is not None else False 7228 ''' 7229 7230 ''' 7231 self.username = username if username is not None else '' 7232 ''' 7233 7234 ''' 7235 7236 def __repr__(self): 7237 return '<sdm.MongoHost ' + \ 7238 'auth_database: ' + repr(self.auth_database) + ' ' +\ 7239 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 7240 'healthy: ' + repr(self.healthy) + ' ' +\ 7241 'hostname: ' + repr(self.hostname) + ' ' +\ 7242 'id: ' + repr(self.id) + ' ' +\ 7243 'name: ' + repr(self.name) + ' ' +\ 7244 'password: ' + repr(self.password) + ' ' +\ 7245 'port: ' + repr(self.port) + ' ' +\ 7246 'port_override: ' + repr(self.port_override) + ' ' +\ 7247 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 7248 'tags: ' + repr(self.tags) + ' ' +\ 7249 'tls_required: ' + repr(self.tls_required) + ' ' +\ 7250 'username: ' + repr(self.username) + ' ' +\ 7251 '>' 7252 7253 def to_dict(self): 7254 return { 7255 'auth_database': self.auth_database, 7256 'egress_filter': self.egress_filter, 7257 'healthy': self.healthy, 7258 'hostname': self.hostname, 7259 'id': self.id, 7260 'name': self.name, 7261 'password': self.password, 7262 'port': self.port, 7263 'port_override': self.port_override, 7264 'secret_store_id': self.secret_store_id, 7265 'tags': self.tags, 7266 'tls_required': self.tls_required, 7267 'username': self.username, 7268 } 7269 7270 @classmethod 7271 def from_dict(cls, d): 7272 return cls( 7273 auth_database=d.get('auth_database'), 7274 egress_filter=d.get('egress_filter'), 7275 healthy=d.get('healthy'), 7276 hostname=d.get('hostname'), 7277 id=d.get('id'), 7278 name=d.get('name'), 7279 password=d.get('password'), 7280 port=d.get('port'), 7281 port_override=d.get('port_override'), 7282 secret_store_id=d.get('secret_store_id'), 7283 tags=d.get('tags'), 7284 tls_required=d.get('tls_required'), 7285 username=d.get('username'), 7286 )
#
MongoHost(
auth_database=None,
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
password=None,
port=None,
port_override=None,
secret_store_id=None,
tags=None,
tls_required=None,
username=None
)
View Source
7167 def __init__( 7168 self, 7169 auth_database=None, 7170 egress_filter=None, 7171 healthy=None, 7172 hostname=None, 7173 id=None, 7174 name=None, 7175 password=None, 7176 port=None, 7177 port_override=None, 7178 secret_store_id=None, 7179 tags=None, 7180 tls_required=None, 7181 username=None, 7182 ): 7183 self.auth_database = auth_database if auth_database is not None else '' 7184 ''' 7185 7186 ''' 7187 self.egress_filter = egress_filter if egress_filter is not None else '' 7188 ''' 7189 A filter applied to the routing logic to pin datasource to nodes. 7190 ''' 7191 self.healthy = healthy if healthy is not None else False 7192 ''' 7193 True if the datasource is reachable and the credentials are valid. 7194 ''' 7195 self.hostname = hostname if hostname is not None else '' 7196 ''' 7197 7198 ''' 7199 self.id = id if id is not None else '' 7200 ''' 7201 Unique identifier of the Resource. 7202 ''' 7203 self.name = name if name is not None else '' 7204 ''' 7205 Unique human-readable name of the Resource. 7206 ''' 7207 self.password = password if password is not None else '' 7208 ''' 7209 7210 ''' 7211 self.port = port if port is not None else 0 7212 ''' 7213 7214 ''' 7215 self.port_override = port_override if port_override is not None else 0 7216 ''' 7217 7218 ''' 7219 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 7220 ''' 7221 ID of the secret store containing credentials for this resource, if any. 7222 ''' 7223 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 7224 ''' 7225 Tags is a map of key, value pairs. 7226 ''' 7227 self.tls_required = tls_required if tls_required is not None else False 7228 ''' 7229 7230 ''' 7231 self.username = username if username is not None else '' 7232 ''' 7233 7234 '''
#
auth_database
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
password
#
port
#
port_override
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
tls_required
#
username
View Source
7253 def to_dict(self): 7254 return { 7255 'auth_database': self.auth_database, 7256 'egress_filter': self.egress_filter, 7257 'healthy': self.healthy, 7258 'hostname': self.hostname, 7259 'id': self.id, 7260 'name': self.name, 7261 'password': self.password, 7262 'port': self.port, 7263 'port_override': self.port_override, 7264 'secret_store_id': self.secret_store_id, 7265 'tags': self.tags, 7266 'tls_required': self.tls_required, 7267 'username': self.username, 7268 }
View Source
7270 @classmethod 7271 def from_dict(cls, d): 7272 return cls( 7273 auth_database=d.get('auth_database'), 7274 egress_filter=d.get('egress_filter'), 7275 healthy=d.get('healthy'), 7276 hostname=d.get('hostname'), 7277 id=d.get('id'), 7278 name=d.get('name'), 7279 password=d.get('password'), 7280 port=d.get('port'), 7281 port_override=d.get('port_override'), 7282 secret_store_id=d.get('secret_store_id'), 7283 tags=d.get('tags'), 7284 tls_required=d.get('tls_required'), 7285 username=d.get('username'), 7286 )
View Source
7289class MongoLegacyHost: 7290 ''' 7291 7292 ''' 7293 __slots__ = [ 7294 'auth_database', 7295 'egress_filter', 7296 'healthy', 7297 'hostname', 7298 'id', 7299 'name', 7300 'password', 7301 'port', 7302 'port_override', 7303 'replica_set', 7304 'secret_store_id', 7305 'tags', 7306 'tls_required', 7307 'username', 7308 ] 7309 7310 def __init__( 7311 self, 7312 auth_database=None, 7313 egress_filter=None, 7314 healthy=None, 7315 hostname=None, 7316 id=None, 7317 name=None, 7318 password=None, 7319 port=None, 7320 port_override=None, 7321 replica_set=None, 7322 secret_store_id=None, 7323 tags=None, 7324 tls_required=None, 7325 username=None, 7326 ): 7327 self.auth_database = auth_database if auth_database is not None else '' 7328 ''' 7329 7330 ''' 7331 self.egress_filter = egress_filter if egress_filter is not None else '' 7332 ''' 7333 A filter applied to the routing logic to pin datasource to nodes. 7334 ''' 7335 self.healthy = healthy if healthy is not None else False 7336 ''' 7337 True if the datasource is reachable and the credentials are valid. 7338 ''' 7339 self.hostname = hostname if hostname is not None else '' 7340 ''' 7341 7342 ''' 7343 self.id = id if id is not None else '' 7344 ''' 7345 Unique identifier of the Resource. 7346 ''' 7347 self.name = name if name is not None else '' 7348 ''' 7349 Unique human-readable name of the Resource. 7350 ''' 7351 self.password = password if password is not None else '' 7352 ''' 7353 7354 ''' 7355 self.port = port if port is not None else 0 7356 ''' 7357 7358 ''' 7359 self.port_override = port_override if port_override is not None else 0 7360 ''' 7361 7362 ''' 7363 self.replica_set = replica_set if replica_set is not None else '' 7364 ''' 7365 7366 ''' 7367 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 7368 ''' 7369 ID of the secret store containing credentials for this resource, if any. 7370 ''' 7371 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 7372 ''' 7373 Tags is a map of key, value pairs. 7374 ''' 7375 self.tls_required = tls_required if tls_required is not None else False 7376 ''' 7377 7378 ''' 7379 self.username = username if username is not None else '' 7380 ''' 7381 7382 ''' 7383 7384 def __repr__(self): 7385 return '<sdm.MongoLegacyHost ' + \ 7386 'auth_database: ' + repr(self.auth_database) + ' ' +\ 7387 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 7388 'healthy: ' + repr(self.healthy) + ' ' +\ 7389 'hostname: ' + repr(self.hostname) + ' ' +\ 7390 'id: ' + repr(self.id) + ' ' +\ 7391 'name: ' + repr(self.name) + ' ' +\ 7392 'password: ' + repr(self.password) + ' ' +\ 7393 'port: ' + repr(self.port) + ' ' +\ 7394 'port_override: ' + repr(self.port_override) + ' ' +\ 7395 'replica_set: ' + repr(self.replica_set) + ' ' +\ 7396 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 7397 'tags: ' + repr(self.tags) + ' ' +\ 7398 'tls_required: ' + repr(self.tls_required) + ' ' +\ 7399 'username: ' + repr(self.username) + ' ' +\ 7400 '>' 7401 7402 def to_dict(self): 7403 return { 7404 'auth_database': self.auth_database, 7405 'egress_filter': self.egress_filter, 7406 'healthy': self.healthy, 7407 'hostname': self.hostname, 7408 'id': self.id, 7409 'name': self.name, 7410 'password': self.password, 7411 'port': self.port, 7412 'port_override': self.port_override, 7413 'replica_set': self.replica_set, 7414 'secret_store_id': self.secret_store_id, 7415 'tags': self.tags, 7416 'tls_required': self.tls_required, 7417 'username': self.username, 7418 } 7419 7420 @classmethod 7421 def from_dict(cls, d): 7422 return cls( 7423 auth_database=d.get('auth_database'), 7424 egress_filter=d.get('egress_filter'), 7425 healthy=d.get('healthy'), 7426 hostname=d.get('hostname'), 7427 id=d.get('id'), 7428 name=d.get('name'), 7429 password=d.get('password'), 7430 port=d.get('port'), 7431 port_override=d.get('port_override'), 7432 replica_set=d.get('replica_set'), 7433 secret_store_id=d.get('secret_store_id'), 7434 tags=d.get('tags'), 7435 tls_required=d.get('tls_required'), 7436 username=d.get('username'), 7437 )
#
MongoLegacyHost(
auth_database=None,
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
password=None,
port=None,
port_override=None,
replica_set=None,
secret_store_id=None,
tags=None,
tls_required=None,
username=None
)
View Source
7310 def __init__( 7311 self, 7312 auth_database=None, 7313 egress_filter=None, 7314 healthy=None, 7315 hostname=None, 7316 id=None, 7317 name=None, 7318 password=None, 7319 port=None, 7320 port_override=None, 7321 replica_set=None, 7322 secret_store_id=None, 7323 tags=None, 7324 tls_required=None, 7325 username=None, 7326 ): 7327 self.auth_database = auth_database if auth_database is not None else '' 7328 ''' 7329 7330 ''' 7331 self.egress_filter = egress_filter if egress_filter is not None else '' 7332 ''' 7333 A filter applied to the routing logic to pin datasource to nodes. 7334 ''' 7335 self.healthy = healthy if healthy is not None else False 7336 ''' 7337 True if the datasource is reachable and the credentials are valid. 7338 ''' 7339 self.hostname = hostname if hostname is not None else '' 7340 ''' 7341 7342 ''' 7343 self.id = id if id is not None else '' 7344 ''' 7345 Unique identifier of the Resource. 7346 ''' 7347 self.name = name if name is not None else '' 7348 ''' 7349 Unique human-readable name of the Resource. 7350 ''' 7351 self.password = password if password is not None else '' 7352 ''' 7353 7354 ''' 7355 self.port = port if port is not None else 0 7356 ''' 7357 7358 ''' 7359 self.port_override = port_override if port_override is not None else 0 7360 ''' 7361 7362 ''' 7363 self.replica_set = replica_set if replica_set is not None else '' 7364 ''' 7365 7366 ''' 7367 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 7368 ''' 7369 ID of the secret store containing credentials for this resource, if any. 7370 ''' 7371 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 7372 ''' 7373 Tags is a map of key, value pairs. 7374 ''' 7375 self.tls_required = tls_required if tls_required is not None else False 7376 ''' 7377 7378 ''' 7379 self.username = username if username is not None else '' 7380 ''' 7381 7382 '''
#
auth_database
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
password
#
port
#
port_override
#
replica_set
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
tls_required
#
username
View Source
7402 def to_dict(self): 7403 return { 7404 'auth_database': self.auth_database, 7405 'egress_filter': self.egress_filter, 7406 'healthy': self.healthy, 7407 'hostname': self.hostname, 7408 'id': self.id, 7409 'name': self.name, 7410 'password': self.password, 7411 'port': self.port, 7412 'port_override': self.port_override, 7413 'replica_set': self.replica_set, 7414 'secret_store_id': self.secret_store_id, 7415 'tags': self.tags, 7416 'tls_required': self.tls_required, 7417 'username': self.username, 7418 }
View Source
7420 @classmethod 7421 def from_dict(cls, d): 7422 return cls( 7423 auth_database=d.get('auth_database'), 7424 egress_filter=d.get('egress_filter'), 7425 healthy=d.get('healthy'), 7426 hostname=d.get('hostname'), 7427 id=d.get('id'), 7428 name=d.get('name'), 7429 password=d.get('password'), 7430 port=d.get('port'), 7431 port_override=d.get('port_override'), 7432 replica_set=d.get('replica_set'), 7433 secret_store_id=d.get('secret_store_id'), 7434 tags=d.get('tags'), 7435 tls_required=d.get('tls_required'), 7436 username=d.get('username'), 7437 )
View Source
7440class MongoLegacyReplicaset: 7441 ''' 7442 7443 ''' 7444 __slots__ = [ 7445 'auth_database', 7446 'connect_to_replica', 7447 'egress_filter', 7448 'healthy', 7449 'hostname', 7450 'id', 7451 'name', 7452 'password', 7453 'port', 7454 'port_override', 7455 'replica_set', 7456 'secret_store_id', 7457 'tags', 7458 'tls_required', 7459 'username', 7460 ] 7461 7462 def __init__( 7463 self, 7464 auth_database=None, 7465 connect_to_replica=None, 7466 egress_filter=None, 7467 healthy=None, 7468 hostname=None, 7469 id=None, 7470 name=None, 7471 password=None, 7472 port=None, 7473 port_override=None, 7474 replica_set=None, 7475 secret_store_id=None, 7476 tags=None, 7477 tls_required=None, 7478 username=None, 7479 ): 7480 self.auth_database = auth_database if auth_database is not None else '' 7481 ''' 7482 7483 ''' 7484 self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False 7485 ''' 7486 7487 ''' 7488 self.egress_filter = egress_filter if egress_filter is not None else '' 7489 ''' 7490 A filter applied to the routing logic to pin datasource to nodes. 7491 ''' 7492 self.healthy = healthy if healthy is not None else False 7493 ''' 7494 True if the datasource is reachable and the credentials are valid. 7495 ''' 7496 self.hostname = hostname if hostname is not None else '' 7497 ''' 7498 7499 ''' 7500 self.id = id if id is not None else '' 7501 ''' 7502 Unique identifier of the Resource. 7503 ''' 7504 self.name = name if name is not None else '' 7505 ''' 7506 Unique human-readable name of the Resource. 7507 ''' 7508 self.password = password if password is not None else '' 7509 ''' 7510 7511 ''' 7512 self.port = port if port is not None else 0 7513 ''' 7514 7515 ''' 7516 self.port_override = port_override if port_override is not None else 0 7517 ''' 7518 7519 ''' 7520 self.replica_set = replica_set if replica_set is not None else '' 7521 ''' 7522 7523 ''' 7524 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 7525 ''' 7526 ID of the secret store containing credentials for this resource, if any. 7527 ''' 7528 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 7529 ''' 7530 Tags is a map of key, value pairs. 7531 ''' 7532 self.tls_required = tls_required if tls_required is not None else False 7533 ''' 7534 7535 ''' 7536 self.username = username if username is not None else '' 7537 ''' 7538 7539 ''' 7540 7541 def __repr__(self): 7542 return '<sdm.MongoLegacyReplicaset ' + \ 7543 'auth_database: ' + repr(self.auth_database) + ' ' +\ 7544 'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\ 7545 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 7546 'healthy: ' + repr(self.healthy) + ' ' +\ 7547 'hostname: ' + repr(self.hostname) + ' ' +\ 7548 'id: ' + repr(self.id) + ' ' +\ 7549 'name: ' + repr(self.name) + ' ' +\ 7550 'password: ' + repr(self.password) + ' ' +\ 7551 'port: ' + repr(self.port) + ' ' +\ 7552 'port_override: ' + repr(self.port_override) + ' ' +\ 7553 'replica_set: ' + repr(self.replica_set) + ' ' +\ 7554 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 7555 'tags: ' + repr(self.tags) + ' ' +\ 7556 'tls_required: ' + repr(self.tls_required) + ' ' +\ 7557 'username: ' + repr(self.username) + ' ' +\ 7558 '>' 7559 7560 def to_dict(self): 7561 return { 7562 'auth_database': self.auth_database, 7563 'connect_to_replica': self.connect_to_replica, 7564 'egress_filter': self.egress_filter, 7565 'healthy': self.healthy, 7566 'hostname': self.hostname, 7567 'id': self.id, 7568 'name': self.name, 7569 'password': self.password, 7570 'port': self.port, 7571 'port_override': self.port_override, 7572 'replica_set': self.replica_set, 7573 'secret_store_id': self.secret_store_id, 7574 'tags': self.tags, 7575 'tls_required': self.tls_required, 7576 'username': self.username, 7577 } 7578 7579 @classmethod 7580 def from_dict(cls, d): 7581 return cls( 7582 auth_database=d.get('auth_database'), 7583 connect_to_replica=d.get('connect_to_replica'), 7584 egress_filter=d.get('egress_filter'), 7585 healthy=d.get('healthy'), 7586 hostname=d.get('hostname'), 7587 id=d.get('id'), 7588 name=d.get('name'), 7589 password=d.get('password'), 7590 port=d.get('port'), 7591 port_override=d.get('port_override'), 7592 replica_set=d.get('replica_set'), 7593 secret_store_id=d.get('secret_store_id'), 7594 tags=d.get('tags'), 7595 tls_required=d.get('tls_required'), 7596 username=d.get('username'), 7597 )
#
MongoLegacyReplicaset(
auth_database=None,
connect_to_replica=None,
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
password=None,
port=None,
port_override=None,
replica_set=None,
secret_store_id=None,
tags=None,
tls_required=None,
username=None
)
View Source
7462 def __init__( 7463 self, 7464 auth_database=None, 7465 connect_to_replica=None, 7466 egress_filter=None, 7467 healthy=None, 7468 hostname=None, 7469 id=None, 7470 name=None, 7471 password=None, 7472 port=None, 7473 port_override=None, 7474 replica_set=None, 7475 secret_store_id=None, 7476 tags=None, 7477 tls_required=None, 7478 username=None, 7479 ): 7480 self.auth_database = auth_database if auth_database is not None else '' 7481 ''' 7482 7483 ''' 7484 self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False 7485 ''' 7486 7487 ''' 7488 self.egress_filter = egress_filter if egress_filter is not None else '' 7489 ''' 7490 A filter applied to the routing logic to pin datasource to nodes. 7491 ''' 7492 self.healthy = healthy if healthy is not None else False 7493 ''' 7494 True if the datasource is reachable and the credentials are valid. 7495 ''' 7496 self.hostname = hostname if hostname is not None else '' 7497 ''' 7498 7499 ''' 7500 self.id = id if id is not None else '' 7501 ''' 7502 Unique identifier of the Resource. 7503 ''' 7504 self.name = name if name is not None else '' 7505 ''' 7506 Unique human-readable name of the Resource. 7507 ''' 7508 self.password = password if password is not None else '' 7509 ''' 7510 7511 ''' 7512 self.port = port if port is not None else 0 7513 ''' 7514 7515 ''' 7516 self.port_override = port_override if port_override is not None else 0 7517 ''' 7518 7519 ''' 7520 self.replica_set = replica_set if replica_set is not None else '' 7521 ''' 7522 7523 ''' 7524 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 7525 ''' 7526 ID of the secret store containing credentials for this resource, if any. 7527 ''' 7528 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 7529 ''' 7530 Tags is a map of key, value pairs. 7531 ''' 7532 self.tls_required = tls_required if tls_required is not None else False 7533 ''' 7534 7535 ''' 7536 self.username = username if username is not None else '' 7537 ''' 7538 7539 '''
#
auth_database
#
connect_to_replica
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
password
#
port
#
port_override
#
replica_set
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
tls_required
#
username
View Source
7560 def to_dict(self): 7561 return { 7562 'auth_database': self.auth_database, 7563 'connect_to_replica': self.connect_to_replica, 7564 'egress_filter': self.egress_filter, 7565 'healthy': self.healthy, 7566 'hostname': self.hostname, 7567 'id': self.id, 7568 'name': self.name, 7569 'password': self.password, 7570 'port': self.port, 7571 'port_override': self.port_override, 7572 'replica_set': self.replica_set, 7573 'secret_store_id': self.secret_store_id, 7574 'tags': self.tags, 7575 'tls_required': self.tls_required, 7576 'username': self.username, 7577 }
View Source
7579 @classmethod 7580 def from_dict(cls, d): 7581 return cls( 7582 auth_database=d.get('auth_database'), 7583 connect_to_replica=d.get('connect_to_replica'), 7584 egress_filter=d.get('egress_filter'), 7585 healthy=d.get('healthy'), 7586 hostname=d.get('hostname'), 7587 id=d.get('id'), 7588 name=d.get('name'), 7589 password=d.get('password'), 7590 port=d.get('port'), 7591 port_override=d.get('port_override'), 7592 replica_set=d.get('replica_set'), 7593 secret_store_id=d.get('secret_store_id'), 7594 tags=d.get('tags'), 7595 tls_required=d.get('tls_required'), 7596 username=d.get('username'), 7597 )
View Source
7600class MongoReplicaSet: 7601 ''' 7602 7603 ''' 7604 __slots__ = [ 7605 'auth_database', 7606 'connect_to_replica', 7607 'egress_filter', 7608 'healthy', 7609 'hostname', 7610 'id', 7611 'name', 7612 'password', 7613 'port', 7614 'port_override', 7615 'replica_set', 7616 'secret_store_id', 7617 'tags', 7618 'tls_required', 7619 'username', 7620 ] 7621 7622 def __init__( 7623 self, 7624 auth_database=None, 7625 connect_to_replica=None, 7626 egress_filter=None, 7627 healthy=None, 7628 hostname=None, 7629 id=None, 7630 name=None, 7631 password=None, 7632 port=None, 7633 port_override=None, 7634 replica_set=None, 7635 secret_store_id=None, 7636 tags=None, 7637 tls_required=None, 7638 username=None, 7639 ): 7640 self.auth_database = auth_database if auth_database is not None else '' 7641 ''' 7642 7643 ''' 7644 self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False 7645 ''' 7646 7647 ''' 7648 self.egress_filter = egress_filter if egress_filter is not None else '' 7649 ''' 7650 A filter applied to the routing logic to pin datasource to nodes. 7651 ''' 7652 self.healthy = healthy if healthy is not None else False 7653 ''' 7654 True if the datasource is reachable and the credentials are valid. 7655 ''' 7656 self.hostname = hostname if hostname is not None else '' 7657 ''' 7658 7659 ''' 7660 self.id = id if id is not None else '' 7661 ''' 7662 Unique identifier of the Resource. 7663 ''' 7664 self.name = name if name is not None else '' 7665 ''' 7666 Unique human-readable name of the Resource. 7667 ''' 7668 self.password = password if password is not None else '' 7669 ''' 7670 7671 ''' 7672 self.port = port if port is not None else 0 7673 ''' 7674 7675 ''' 7676 self.port_override = port_override if port_override is not None else 0 7677 ''' 7678 7679 ''' 7680 self.replica_set = replica_set if replica_set is not None else '' 7681 ''' 7682 7683 ''' 7684 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 7685 ''' 7686 ID of the secret store containing credentials for this resource, if any. 7687 ''' 7688 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 7689 ''' 7690 Tags is a map of key, value pairs. 7691 ''' 7692 self.tls_required = tls_required if tls_required is not None else False 7693 ''' 7694 7695 ''' 7696 self.username = username if username is not None else '' 7697 ''' 7698 7699 ''' 7700 7701 def __repr__(self): 7702 return '<sdm.MongoReplicaSet ' + \ 7703 'auth_database: ' + repr(self.auth_database) + ' ' +\ 7704 'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\ 7705 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 7706 'healthy: ' + repr(self.healthy) + ' ' +\ 7707 'hostname: ' + repr(self.hostname) + ' ' +\ 7708 'id: ' + repr(self.id) + ' ' +\ 7709 'name: ' + repr(self.name) + ' ' +\ 7710 'password: ' + repr(self.password) + ' ' +\ 7711 'port: ' + repr(self.port) + ' ' +\ 7712 'port_override: ' + repr(self.port_override) + ' ' +\ 7713 'replica_set: ' + repr(self.replica_set) + ' ' +\ 7714 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 7715 'tags: ' + repr(self.tags) + ' ' +\ 7716 'tls_required: ' + repr(self.tls_required) + ' ' +\ 7717 'username: ' + repr(self.username) + ' ' +\ 7718 '>' 7719 7720 def to_dict(self): 7721 return { 7722 'auth_database': self.auth_database, 7723 'connect_to_replica': self.connect_to_replica, 7724 'egress_filter': self.egress_filter, 7725 'healthy': self.healthy, 7726 'hostname': self.hostname, 7727 'id': self.id, 7728 'name': self.name, 7729 'password': self.password, 7730 'port': self.port, 7731 'port_override': self.port_override, 7732 'replica_set': self.replica_set, 7733 'secret_store_id': self.secret_store_id, 7734 'tags': self.tags, 7735 'tls_required': self.tls_required, 7736 'username': self.username, 7737 } 7738 7739 @classmethod 7740 def from_dict(cls, d): 7741 return cls( 7742 auth_database=d.get('auth_database'), 7743 connect_to_replica=d.get('connect_to_replica'), 7744 egress_filter=d.get('egress_filter'), 7745 healthy=d.get('healthy'), 7746 hostname=d.get('hostname'), 7747 id=d.get('id'), 7748 name=d.get('name'), 7749 password=d.get('password'), 7750 port=d.get('port'), 7751 port_override=d.get('port_override'), 7752 replica_set=d.get('replica_set'), 7753 secret_store_id=d.get('secret_store_id'), 7754 tags=d.get('tags'), 7755 tls_required=d.get('tls_required'), 7756 username=d.get('username'), 7757 )
#
MongoReplicaSet(
auth_database=None,
connect_to_replica=None,
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
password=None,
port=None,
port_override=None,
replica_set=None,
secret_store_id=None,
tags=None,
tls_required=None,
username=None
)
View Source
7622 def __init__( 7623 self, 7624 auth_database=None, 7625 connect_to_replica=None, 7626 egress_filter=None, 7627 healthy=None, 7628 hostname=None, 7629 id=None, 7630 name=None, 7631 password=None, 7632 port=None, 7633 port_override=None, 7634 replica_set=None, 7635 secret_store_id=None, 7636 tags=None, 7637 tls_required=None, 7638 username=None, 7639 ): 7640 self.auth_database = auth_database if auth_database is not None else '' 7641 ''' 7642 7643 ''' 7644 self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False 7645 ''' 7646 7647 ''' 7648 self.egress_filter = egress_filter if egress_filter is not None else '' 7649 ''' 7650 A filter applied to the routing logic to pin datasource to nodes. 7651 ''' 7652 self.healthy = healthy if healthy is not None else False 7653 ''' 7654 True if the datasource is reachable and the credentials are valid. 7655 ''' 7656 self.hostname = hostname if hostname is not None else '' 7657 ''' 7658 7659 ''' 7660 self.id = id if id is not None else '' 7661 ''' 7662 Unique identifier of the Resource. 7663 ''' 7664 self.name = name if name is not None else '' 7665 ''' 7666 Unique human-readable name of the Resource. 7667 ''' 7668 self.password = password if password is not None else '' 7669 ''' 7670 7671 ''' 7672 self.port = port if port is not None else 0 7673 ''' 7674 7675 ''' 7676 self.port_override = port_override if port_override is not None else 0 7677 ''' 7678 7679 ''' 7680 self.replica_set = replica_set if replica_set is not None else '' 7681 ''' 7682 7683 ''' 7684 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 7685 ''' 7686 ID of the secret store containing credentials for this resource, if any. 7687 ''' 7688 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 7689 ''' 7690 Tags is a map of key, value pairs. 7691 ''' 7692 self.tls_required = tls_required if tls_required is not None else False 7693 ''' 7694 7695 ''' 7696 self.username = username if username is not None else '' 7697 ''' 7698 7699 '''
#
auth_database
#
connect_to_replica
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
password
#
port
#
port_override
#
replica_set
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
tls_required
#
username
View Source
7720 def to_dict(self): 7721 return { 7722 'auth_database': self.auth_database, 7723 'connect_to_replica': self.connect_to_replica, 7724 'egress_filter': self.egress_filter, 7725 'healthy': self.healthy, 7726 'hostname': self.hostname, 7727 'id': self.id, 7728 'name': self.name, 7729 'password': self.password, 7730 'port': self.port, 7731 'port_override': self.port_override, 7732 'replica_set': self.replica_set, 7733 'secret_store_id': self.secret_store_id, 7734 'tags': self.tags, 7735 'tls_required': self.tls_required, 7736 'username': self.username, 7737 }
View Source
7739 @classmethod 7740 def from_dict(cls, d): 7741 return cls( 7742 auth_database=d.get('auth_database'), 7743 connect_to_replica=d.get('connect_to_replica'), 7744 egress_filter=d.get('egress_filter'), 7745 healthy=d.get('healthy'), 7746 hostname=d.get('hostname'), 7747 id=d.get('id'), 7748 name=d.get('name'), 7749 password=d.get('password'), 7750 port=d.get('port'), 7751 port_override=d.get('port_override'), 7752 replica_set=d.get('replica_set'), 7753 secret_store_id=d.get('secret_store_id'), 7754 tags=d.get('tags'), 7755 tls_required=d.get('tls_required'), 7756 username=d.get('username'), 7757 )
View Source
7760class MongoShardedCluster: 7761 ''' 7762 7763 ''' 7764 __slots__ = [ 7765 'auth_database', 7766 'egress_filter', 7767 'healthy', 7768 'hostname', 7769 'id', 7770 'name', 7771 'password', 7772 'port_override', 7773 'secret_store_id', 7774 'tags', 7775 'tls_required', 7776 'username', 7777 ] 7778 7779 def __init__( 7780 self, 7781 auth_database=None, 7782 egress_filter=None, 7783 healthy=None, 7784 hostname=None, 7785 id=None, 7786 name=None, 7787 password=None, 7788 port_override=None, 7789 secret_store_id=None, 7790 tags=None, 7791 tls_required=None, 7792 username=None, 7793 ): 7794 self.auth_database = auth_database if auth_database is not None else '' 7795 ''' 7796 7797 ''' 7798 self.egress_filter = egress_filter if egress_filter is not None else '' 7799 ''' 7800 A filter applied to the routing logic to pin datasource to nodes. 7801 ''' 7802 self.healthy = healthy if healthy is not None else False 7803 ''' 7804 True if the datasource is reachable and the credentials are valid. 7805 ''' 7806 self.hostname = hostname if hostname is not None else '' 7807 ''' 7808 7809 ''' 7810 self.id = id if id is not None else '' 7811 ''' 7812 Unique identifier of the Resource. 7813 ''' 7814 self.name = name if name is not None else '' 7815 ''' 7816 Unique human-readable name of the Resource. 7817 ''' 7818 self.password = password if password is not None else '' 7819 ''' 7820 7821 ''' 7822 self.port_override = port_override if port_override is not None else 0 7823 ''' 7824 7825 ''' 7826 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 7827 ''' 7828 ID of the secret store containing credentials for this resource, if any. 7829 ''' 7830 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 7831 ''' 7832 Tags is a map of key, value pairs. 7833 ''' 7834 self.tls_required = tls_required if tls_required is not None else False 7835 ''' 7836 7837 ''' 7838 self.username = username if username is not None else '' 7839 ''' 7840 7841 ''' 7842 7843 def __repr__(self): 7844 return '<sdm.MongoShardedCluster ' + \ 7845 'auth_database: ' + repr(self.auth_database) + ' ' +\ 7846 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 7847 'healthy: ' + repr(self.healthy) + ' ' +\ 7848 'hostname: ' + repr(self.hostname) + ' ' +\ 7849 'id: ' + repr(self.id) + ' ' +\ 7850 'name: ' + repr(self.name) + ' ' +\ 7851 'password: ' + repr(self.password) + ' ' +\ 7852 'port_override: ' + repr(self.port_override) + ' ' +\ 7853 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 7854 'tags: ' + repr(self.tags) + ' ' +\ 7855 'tls_required: ' + repr(self.tls_required) + ' ' +\ 7856 'username: ' + repr(self.username) + ' ' +\ 7857 '>' 7858 7859 def to_dict(self): 7860 return { 7861 'auth_database': self.auth_database, 7862 'egress_filter': self.egress_filter, 7863 'healthy': self.healthy, 7864 'hostname': self.hostname, 7865 'id': self.id, 7866 'name': self.name, 7867 'password': self.password, 7868 'port_override': self.port_override, 7869 'secret_store_id': self.secret_store_id, 7870 'tags': self.tags, 7871 'tls_required': self.tls_required, 7872 'username': self.username, 7873 } 7874 7875 @classmethod 7876 def from_dict(cls, d): 7877 return cls( 7878 auth_database=d.get('auth_database'), 7879 egress_filter=d.get('egress_filter'), 7880 healthy=d.get('healthy'), 7881 hostname=d.get('hostname'), 7882 id=d.get('id'), 7883 name=d.get('name'), 7884 password=d.get('password'), 7885 port_override=d.get('port_override'), 7886 secret_store_id=d.get('secret_store_id'), 7887 tags=d.get('tags'), 7888 tls_required=d.get('tls_required'), 7889 username=d.get('username'), 7890 )
#
MongoShardedCluster(
auth_database=None,
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
password=None,
port_override=None,
secret_store_id=None,
tags=None,
tls_required=None,
username=None
)
View Source
7779 def __init__( 7780 self, 7781 auth_database=None, 7782 egress_filter=None, 7783 healthy=None, 7784 hostname=None, 7785 id=None, 7786 name=None, 7787 password=None, 7788 port_override=None, 7789 secret_store_id=None, 7790 tags=None, 7791 tls_required=None, 7792 username=None, 7793 ): 7794 self.auth_database = auth_database if auth_database is not None else '' 7795 ''' 7796 7797 ''' 7798 self.egress_filter = egress_filter if egress_filter is not None else '' 7799 ''' 7800 A filter applied to the routing logic to pin datasource to nodes. 7801 ''' 7802 self.healthy = healthy if healthy is not None else False 7803 ''' 7804 True if the datasource is reachable and the credentials are valid. 7805 ''' 7806 self.hostname = hostname if hostname is not None else '' 7807 ''' 7808 7809 ''' 7810 self.id = id if id is not None else '' 7811 ''' 7812 Unique identifier of the Resource. 7813 ''' 7814 self.name = name if name is not None else '' 7815 ''' 7816 Unique human-readable name of the Resource. 7817 ''' 7818 self.password = password if password is not None else '' 7819 ''' 7820 7821 ''' 7822 self.port_override = port_override if port_override is not None else 0 7823 ''' 7824 7825 ''' 7826 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 7827 ''' 7828 ID of the secret store containing credentials for this resource, if any. 7829 ''' 7830 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 7831 ''' 7832 Tags is a map of key, value pairs. 7833 ''' 7834 self.tls_required = tls_required if tls_required is not None else False 7835 ''' 7836 7837 ''' 7838 self.username = username if username is not None else '' 7839 ''' 7840 7841 '''
#
auth_database
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
password
#
port_override
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
tls_required
#
username
View Source
7859 def to_dict(self): 7860 return { 7861 'auth_database': self.auth_database, 7862 'egress_filter': self.egress_filter, 7863 'healthy': self.healthy, 7864 'hostname': self.hostname, 7865 'id': self.id, 7866 'name': self.name, 7867 'password': self.password, 7868 'port_override': self.port_override, 7869 'secret_store_id': self.secret_store_id, 7870 'tags': self.tags, 7871 'tls_required': self.tls_required, 7872 'username': self.username, 7873 }
View Source
7875 @classmethod 7876 def from_dict(cls, d): 7877 return cls( 7878 auth_database=d.get('auth_database'), 7879 egress_filter=d.get('egress_filter'), 7880 healthy=d.get('healthy'), 7881 hostname=d.get('hostname'), 7882 id=d.get('id'), 7883 name=d.get('name'), 7884 password=d.get('password'), 7885 port_override=d.get('port_override'), 7886 secret_store_id=d.get('secret_store_id'), 7887 tags=d.get('tags'), 7888 tls_required=d.get('tls_required'), 7889 username=d.get('username'), 7890 )
View Source
7893class Mysql: 7894 ''' 7895 7896 ''' 7897 __slots__ = [ 7898 'database', 7899 'egress_filter', 7900 'healthy', 7901 'hostname', 7902 'id', 7903 'name', 7904 'password', 7905 'port', 7906 'port_override', 7907 'secret_store_id', 7908 'tags', 7909 'username', 7910 ] 7911 7912 def __init__( 7913 self, 7914 database=None, 7915 egress_filter=None, 7916 healthy=None, 7917 hostname=None, 7918 id=None, 7919 name=None, 7920 password=None, 7921 port=None, 7922 port_override=None, 7923 secret_store_id=None, 7924 tags=None, 7925 username=None, 7926 ): 7927 self.database = database if database is not None else '' 7928 ''' 7929 7930 ''' 7931 self.egress_filter = egress_filter if egress_filter is not None else '' 7932 ''' 7933 A filter applied to the routing logic to pin datasource to nodes. 7934 ''' 7935 self.healthy = healthy if healthy is not None else False 7936 ''' 7937 True if the datasource is reachable and the credentials are valid. 7938 ''' 7939 self.hostname = hostname if hostname is not None else '' 7940 ''' 7941 7942 ''' 7943 self.id = id if id is not None else '' 7944 ''' 7945 Unique identifier of the Resource. 7946 ''' 7947 self.name = name if name is not None else '' 7948 ''' 7949 Unique human-readable name of the Resource. 7950 ''' 7951 self.password = password if password is not None else '' 7952 ''' 7953 7954 ''' 7955 self.port = port if port is not None else 0 7956 ''' 7957 7958 ''' 7959 self.port_override = port_override if port_override is not None else 0 7960 ''' 7961 7962 ''' 7963 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 7964 ''' 7965 ID of the secret store containing credentials for this resource, if any. 7966 ''' 7967 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 7968 ''' 7969 Tags is a map of key, value pairs. 7970 ''' 7971 self.username = username if username is not None else '' 7972 ''' 7973 7974 ''' 7975 7976 def __repr__(self): 7977 return '<sdm.Mysql ' + \ 7978 'database: ' + repr(self.database) + ' ' +\ 7979 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 7980 'healthy: ' + repr(self.healthy) + ' ' +\ 7981 'hostname: ' + repr(self.hostname) + ' ' +\ 7982 'id: ' + repr(self.id) + ' ' +\ 7983 'name: ' + repr(self.name) + ' ' +\ 7984 'password: ' + repr(self.password) + ' ' +\ 7985 'port: ' + repr(self.port) + ' ' +\ 7986 'port_override: ' + repr(self.port_override) + ' ' +\ 7987 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 7988 'tags: ' + repr(self.tags) + ' ' +\ 7989 'username: ' + repr(self.username) + ' ' +\ 7990 '>' 7991 7992 def to_dict(self): 7993 return { 7994 'database': self.database, 7995 'egress_filter': self.egress_filter, 7996 'healthy': self.healthy, 7997 'hostname': self.hostname, 7998 'id': self.id, 7999 'name': self.name, 8000 'password': self.password, 8001 'port': self.port, 8002 'port_override': self.port_override, 8003 'secret_store_id': self.secret_store_id, 8004 'tags': self.tags, 8005 'username': self.username, 8006 } 8007 8008 @classmethod 8009 def from_dict(cls, d): 8010 return cls( 8011 database=d.get('database'), 8012 egress_filter=d.get('egress_filter'), 8013 healthy=d.get('healthy'), 8014 hostname=d.get('hostname'), 8015 id=d.get('id'), 8016 name=d.get('name'), 8017 password=d.get('password'), 8018 port=d.get('port'), 8019 port_override=d.get('port_override'), 8020 secret_store_id=d.get('secret_store_id'), 8021 tags=d.get('tags'), 8022 username=d.get('username'), 8023 )
#
Mysql(
database=None,
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
password=None,
port=None,
port_override=None,
secret_store_id=None,
tags=None,
username=None
)
View Source
7912 def __init__( 7913 self, 7914 database=None, 7915 egress_filter=None, 7916 healthy=None, 7917 hostname=None, 7918 id=None, 7919 name=None, 7920 password=None, 7921 port=None, 7922 port_override=None, 7923 secret_store_id=None, 7924 tags=None, 7925 username=None, 7926 ): 7927 self.database = database if database is not None else '' 7928 ''' 7929 7930 ''' 7931 self.egress_filter = egress_filter if egress_filter is not None else '' 7932 ''' 7933 A filter applied to the routing logic to pin datasource to nodes. 7934 ''' 7935 self.healthy = healthy if healthy is not None else False 7936 ''' 7937 True if the datasource is reachable and the credentials are valid. 7938 ''' 7939 self.hostname = hostname if hostname is not None else '' 7940 ''' 7941 7942 ''' 7943 self.id = id if id is not None else '' 7944 ''' 7945 Unique identifier of the Resource. 7946 ''' 7947 self.name = name if name is not None else '' 7948 ''' 7949 Unique human-readable name of the Resource. 7950 ''' 7951 self.password = password if password is not None else '' 7952 ''' 7953 7954 ''' 7955 self.port = port if port is not None else 0 7956 ''' 7957 7958 ''' 7959 self.port_override = port_override if port_override is not None else 0 7960 ''' 7961 7962 ''' 7963 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 7964 ''' 7965 ID of the secret store containing credentials for this resource, if any. 7966 ''' 7967 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 7968 ''' 7969 Tags is a map of key, value pairs. 7970 ''' 7971 self.username = username if username is not None else '' 7972 ''' 7973 7974 '''
#
database
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
password
#
port
#
port_override
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
username
View Source
7992 def to_dict(self): 7993 return { 7994 'database': self.database, 7995 'egress_filter': self.egress_filter, 7996 'healthy': self.healthy, 7997 'hostname': self.hostname, 7998 'id': self.id, 7999 'name': self.name, 8000 'password': self.password, 8001 'port': self.port, 8002 'port_override': self.port_override, 8003 'secret_store_id': self.secret_store_id, 8004 'tags': self.tags, 8005 'username': self.username, 8006 }
View Source
8008 @classmethod 8009 def from_dict(cls, d): 8010 return cls( 8011 database=d.get('database'), 8012 egress_filter=d.get('egress_filter'), 8013 healthy=d.get('healthy'), 8014 hostname=d.get('hostname'), 8015 id=d.get('id'), 8016 name=d.get('name'), 8017 password=d.get('password'), 8018 port=d.get('port'), 8019 port_override=d.get('port_override'), 8020 secret_store_id=d.get('secret_store_id'), 8021 tags=d.get('tags'), 8022 username=d.get('username'), 8023 )
View Source
8026class Neptune: 8027 ''' 8028 8029 ''' 8030 __slots__ = [ 8031 'egress_filter', 8032 'endpoint', 8033 'healthy', 8034 'id', 8035 'name', 8036 'port', 8037 'port_override', 8038 'secret_store_id', 8039 'tags', 8040 ] 8041 8042 def __init__( 8043 self, 8044 egress_filter=None, 8045 endpoint=None, 8046 healthy=None, 8047 id=None, 8048 name=None, 8049 port=None, 8050 port_override=None, 8051 secret_store_id=None, 8052 tags=None, 8053 ): 8054 self.egress_filter = egress_filter if egress_filter is not None else '' 8055 ''' 8056 A filter applied to the routing logic to pin datasource to nodes. 8057 ''' 8058 self.endpoint = endpoint if endpoint is not None else '' 8059 ''' 8060 8061 ''' 8062 self.healthy = healthy if healthy is not None else False 8063 ''' 8064 True if the datasource is reachable and the credentials are valid. 8065 ''' 8066 self.id = id if id is not None else '' 8067 ''' 8068 Unique identifier of the Resource. 8069 ''' 8070 self.name = name if name is not None else '' 8071 ''' 8072 Unique human-readable name of the Resource. 8073 ''' 8074 self.port = port if port is not None else 0 8075 ''' 8076 8077 ''' 8078 self.port_override = port_override if port_override is not None else 0 8079 ''' 8080 8081 ''' 8082 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 8083 ''' 8084 ID of the secret store containing credentials for this resource, if any. 8085 ''' 8086 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 8087 ''' 8088 Tags is a map of key, value pairs. 8089 ''' 8090 8091 def __repr__(self): 8092 return '<sdm.Neptune ' + \ 8093 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 8094 'endpoint: ' + repr(self.endpoint) + ' ' +\ 8095 'healthy: ' + repr(self.healthy) + ' ' +\ 8096 'id: ' + repr(self.id) + ' ' +\ 8097 'name: ' + repr(self.name) + ' ' +\ 8098 'port: ' + repr(self.port) + ' ' +\ 8099 'port_override: ' + repr(self.port_override) + ' ' +\ 8100 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 8101 'tags: ' + repr(self.tags) + ' ' +\ 8102 '>' 8103 8104 def to_dict(self): 8105 return { 8106 'egress_filter': self.egress_filter, 8107 'endpoint': self.endpoint, 8108 'healthy': self.healthy, 8109 'id': self.id, 8110 'name': self.name, 8111 'port': self.port, 8112 'port_override': self.port_override, 8113 'secret_store_id': self.secret_store_id, 8114 'tags': self.tags, 8115 } 8116 8117 @classmethod 8118 def from_dict(cls, d): 8119 return cls( 8120 egress_filter=d.get('egress_filter'), 8121 endpoint=d.get('endpoint'), 8122 healthy=d.get('healthy'), 8123 id=d.get('id'), 8124 name=d.get('name'), 8125 port=d.get('port'), 8126 port_override=d.get('port_override'), 8127 secret_store_id=d.get('secret_store_id'), 8128 tags=d.get('tags'), 8129 )
#
Neptune(
egress_filter=None,
endpoint=None,
healthy=None,
id=None,
name=None,
port=None,
port_override=None,
secret_store_id=None,
tags=None
)
View Source
8042 def __init__( 8043 self, 8044 egress_filter=None, 8045 endpoint=None, 8046 healthy=None, 8047 id=None, 8048 name=None, 8049 port=None, 8050 port_override=None, 8051 secret_store_id=None, 8052 tags=None, 8053 ): 8054 self.egress_filter = egress_filter if egress_filter is not None else '' 8055 ''' 8056 A filter applied to the routing logic to pin datasource to nodes. 8057 ''' 8058 self.endpoint = endpoint if endpoint is not None else '' 8059 ''' 8060 8061 ''' 8062 self.healthy = healthy if healthy is not None else False 8063 ''' 8064 True if the datasource is reachable and the credentials are valid. 8065 ''' 8066 self.id = id if id is not None else '' 8067 ''' 8068 Unique identifier of the Resource. 8069 ''' 8070 self.name = name if name is not None else '' 8071 ''' 8072 Unique human-readable name of the Resource. 8073 ''' 8074 self.port = port if port is not None else 0 8075 ''' 8076 8077 ''' 8078 self.port_override = port_override if port_override is not None else 0 8079 ''' 8080 8081 ''' 8082 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 8083 ''' 8084 ID of the secret store containing credentials for this resource, if any. 8085 ''' 8086 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 8087 ''' 8088 Tags is a map of key, value pairs. 8089 '''
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
endpoint
#
healthy
True if the datasource is reachable and the credentials are valid.
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
port
#
port_override
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
View Source
8104 def to_dict(self): 8105 return { 8106 'egress_filter': self.egress_filter, 8107 'endpoint': self.endpoint, 8108 'healthy': self.healthy, 8109 'id': self.id, 8110 'name': self.name, 8111 'port': self.port, 8112 'port_override': self.port_override, 8113 'secret_store_id': self.secret_store_id, 8114 'tags': self.tags, 8115 }
View Source
8117 @classmethod 8118 def from_dict(cls, d): 8119 return cls( 8120 egress_filter=d.get('egress_filter'), 8121 endpoint=d.get('endpoint'), 8122 healthy=d.get('healthy'), 8123 id=d.get('id'), 8124 name=d.get('name'), 8125 port=d.get('port'), 8126 port_override=d.get('port_override'), 8127 secret_store_id=d.get('secret_store_id'), 8128 tags=d.get('tags'), 8129 )
View Source
8132class NeptuneIAM: 8133 ''' 8134 8135 ''' 8136 __slots__ = [ 8137 'access_key', 8138 'egress_filter', 8139 'endpoint', 8140 'healthy', 8141 'id', 8142 'name', 8143 'port', 8144 'port_override', 8145 'region', 8146 'role_arn', 8147 'role_external_id', 8148 'secret_access_key', 8149 'secret_store_id', 8150 'tags', 8151 ] 8152 8153 def __init__( 8154 self, 8155 access_key=None, 8156 egress_filter=None, 8157 endpoint=None, 8158 healthy=None, 8159 id=None, 8160 name=None, 8161 port=None, 8162 port_override=None, 8163 region=None, 8164 role_arn=None, 8165 role_external_id=None, 8166 secret_access_key=None, 8167 secret_store_id=None, 8168 tags=None, 8169 ): 8170 self.access_key = access_key if access_key is not None else '' 8171 ''' 8172 8173 ''' 8174 self.egress_filter = egress_filter if egress_filter is not None else '' 8175 ''' 8176 A filter applied to the routing logic to pin datasource to nodes. 8177 ''' 8178 self.endpoint = endpoint if endpoint is not None else '' 8179 ''' 8180 8181 ''' 8182 self.healthy = healthy if healthy is not None else False 8183 ''' 8184 True if the datasource is reachable and the credentials are valid. 8185 ''' 8186 self.id = id if id is not None else '' 8187 ''' 8188 Unique identifier of the Resource. 8189 ''' 8190 self.name = name if name is not None else '' 8191 ''' 8192 Unique human-readable name of the Resource. 8193 ''' 8194 self.port = port if port is not None else 0 8195 ''' 8196 8197 ''' 8198 self.port_override = port_override if port_override is not None else 0 8199 ''' 8200 8201 ''' 8202 self.region = region if region is not None else '' 8203 ''' 8204 8205 ''' 8206 self.role_arn = role_arn if role_arn is not None else '' 8207 ''' 8208 8209 ''' 8210 self.role_external_id = role_external_id if role_external_id is not None else '' 8211 ''' 8212 8213 ''' 8214 self.secret_access_key = secret_access_key if secret_access_key is not None else '' 8215 ''' 8216 8217 ''' 8218 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 8219 ''' 8220 ID of the secret store containing credentials for this resource, if any. 8221 ''' 8222 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 8223 ''' 8224 Tags is a map of key, value pairs. 8225 ''' 8226 8227 def __repr__(self): 8228 return '<sdm.NeptuneIAM ' + \ 8229 'access_key: ' + repr(self.access_key) + ' ' +\ 8230 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 8231 'endpoint: ' + repr(self.endpoint) + ' ' +\ 8232 'healthy: ' + repr(self.healthy) + ' ' +\ 8233 'id: ' + repr(self.id) + ' ' +\ 8234 'name: ' + repr(self.name) + ' ' +\ 8235 'port: ' + repr(self.port) + ' ' +\ 8236 'port_override: ' + repr(self.port_override) + ' ' +\ 8237 'region: ' + repr(self.region) + ' ' +\ 8238 'role_arn: ' + repr(self.role_arn) + ' ' +\ 8239 'role_external_id: ' + repr(self.role_external_id) + ' ' +\ 8240 'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\ 8241 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 8242 'tags: ' + repr(self.tags) + ' ' +\ 8243 '>' 8244 8245 def to_dict(self): 8246 return { 8247 'access_key': self.access_key, 8248 'egress_filter': self.egress_filter, 8249 'endpoint': self.endpoint, 8250 'healthy': self.healthy, 8251 'id': self.id, 8252 'name': self.name, 8253 'port': self.port, 8254 'port_override': self.port_override, 8255 'region': self.region, 8256 'role_arn': self.role_arn, 8257 'role_external_id': self.role_external_id, 8258 'secret_access_key': self.secret_access_key, 8259 'secret_store_id': self.secret_store_id, 8260 'tags': self.tags, 8261 } 8262 8263 @classmethod 8264 def from_dict(cls, d): 8265 return cls( 8266 access_key=d.get('access_key'), 8267 egress_filter=d.get('egress_filter'), 8268 endpoint=d.get('endpoint'), 8269 healthy=d.get('healthy'), 8270 id=d.get('id'), 8271 name=d.get('name'), 8272 port=d.get('port'), 8273 port_override=d.get('port_override'), 8274 region=d.get('region'), 8275 role_arn=d.get('role_arn'), 8276 role_external_id=d.get('role_external_id'), 8277 secret_access_key=d.get('secret_access_key'), 8278 secret_store_id=d.get('secret_store_id'), 8279 tags=d.get('tags'), 8280 )
#
NeptuneIAM(
access_key=None,
egress_filter=None,
endpoint=None,
healthy=None,
id=None,
name=None,
port=None,
port_override=None,
region=None,
role_arn=None,
role_external_id=None,
secret_access_key=None,
secret_store_id=None,
tags=None
)
View Source
8153 def __init__( 8154 self, 8155 access_key=None, 8156 egress_filter=None, 8157 endpoint=None, 8158 healthy=None, 8159 id=None, 8160 name=None, 8161 port=None, 8162 port_override=None, 8163 region=None, 8164 role_arn=None, 8165 role_external_id=None, 8166 secret_access_key=None, 8167 secret_store_id=None, 8168 tags=None, 8169 ): 8170 self.access_key = access_key if access_key is not None else '' 8171 ''' 8172 8173 ''' 8174 self.egress_filter = egress_filter if egress_filter is not None else '' 8175 ''' 8176 A filter applied to the routing logic to pin datasource to nodes. 8177 ''' 8178 self.endpoint = endpoint if endpoint is not None else '' 8179 ''' 8180 8181 ''' 8182 self.healthy = healthy if healthy is not None else False 8183 ''' 8184 True if the datasource is reachable and the credentials are valid. 8185 ''' 8186 self.id = id if id is not None else '' 8187 ''' 8188 Unique identifier of the Resource. 8189 ''' 8190 self.name = name if name is not None else '' 8191 ''' 8192 Unique human-readable name of the Resource. 8193 ''' 8194 self.port = port if port is not None else 0 8195 ''' 8196 8197 ''' 8198 self.port_override = port_override if port_override is not None else 0 8199 ''' 8200 8201 ''' 8202 self.region = region if region is not None else '' 8203 ''' 8204 8205 ''' 8206 self.role_arn = role_arn if role_arn is not None else '' 8207 ''' 8208 8209 ''' 8210 self.role_external_id = role_external_id if role_external_id is not None else '' 8211 ''' 8212 8213 ''' 8214 self.secret_access_key = secret_access_key if secret_access_key is not None else '' 8215 ''' 8216 8217 ''' 8218 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 8219 ''' 8220 ID of the secret store containing credentials for this resource, if any. 8221 ''' 8222 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 8223 ''' 8224 Tags is a map of key, value pairs. 8225 '''
#
access_key
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
endpoint
#
healthy
True if the datasource is reachable and the credentials are valid.
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
port
#
port_override
#
region
#
role_arn
#
role_external_id
#
secret_access_key
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
View Source
8245 def to_dict(self): 8246 return { 8247 'access_key': self.access_key, 8248 'egress_filter': self.egress_filter, 8249 'endpoint': self.endpoint, 8250 'healthy': self.healthy, 8251 'id': self.id, 8252 'name': self.name, 8253 'port': self.port, 8254 'port_override': self.port_override, 8255 'region': self.region, 8256 'role_arn': self.role_arn, 8257 'role_external_id': self.role_external_id, 8258 'secret_access_key': self.secret_access_key, 8259 'secret_store_id': self.secret_store_id, 8260 'tags': self.tags, 8261 }
View Source
8263 @classmethod 8264 def from_dict(cls, d): 8265 return cls( 8266 access_key=d.get('access_key'), 8267 egress_filter=d.get('egress_filter'), 8268 endpoint=d.get('endpoint'), 8269 healthy=d.get('healthy'), 8270 id=d.get('id'), 8271 name=d.get('name'), 8272 port=d.get('port'), 8273 port_override=d.get('port_override'), 8274 region=d.get('region'), 8275 role_arn=d.get('role_arn'), 8276 role_external_id=d.get('role_external_id'), 8277 secret_access_key=d.get('secret_access_key'), 8278 secret_store_id=d.get('secret_store_id'), 8279 tags=d.get('tags'), 8280 )
View Source
8283class NodeCreateResponse: 8284 ''' 8285 NodeCreateResponse reports how the Nodes were created in the system. 8286 ''' 8287 __slots__ = [ 8288 'meta', 8289 'node', 8290 'rate_limit', 8291 'token', 8292 ] 8293 8294 def __init__( 8295 self, 8296 meta=None, 8297 node=None, 8298 rate_limit=None, 8299 token=None, 8300 ): 8301 self.meta = meta if meta is not None else None 8302 ''' 8303 Reserved for future use. 8304 ''' 8305 self.node = node if node is not None else None 8306 ''' 8307 The created Node. 8308 ''' 8309 self.rate_limit = rate_limit if rate_limit is not None else None 8310 ''' 8311 Rate limit information. 8312 ''' 8313 self.token = token if token is not None else '' 8314 ''' 8315 The auth token generated for the Node. The Node will use this token to 8316 authenticate with the strongDM API. 8317 ''' 8318 8319 def __repr__(self): 8320 return '<sdm.NodeCreateResponse ' + \ 8321 'meta: ' + repr(self.meta) + ' ' +\ 8322 'node: ' + repr(self.node) + ' ' +\ 8323 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 8324 'token: ' + repr(self.token) + ' ' +\ 8325 '>' 8326 8327 def to_dict(self): 8328 return { 8329 'meta': self.meta, 8330 'node': self.node, 8331 'rate_limit': self.rate_limit, 8332 'token': self.token, 8333 } 8334 8335 @classmethod 8336 def from_dict(cls, d): 8337 return cls( 8338 meta=d.get('meta'), 8339 node=d.get('node'), 8340 rate_limit=d.get('rate_limit'), 8341 token=d.get('token'), 8342 )
NodeCreateResponse reports how the Nodes were created in the system.
View Source
8294 def __init__( 8295 self, 8296 meta=None, 8297 node=None, 8298 rate_limit=None, 8299 token=None, 8300 ): 8301 self.meta = meta if meta is not None else None 8302 ''' 8303 Reserved for future use. 8304 ''' 8305 self.node = node if node is not None else None 8306 ''' 8307 The created Node. 8308 ''' 8309 self.rate_limit = rate_limit if rate_limit is not None else None 8310 ''' 8311 Rate limit information. 8312 ''' 8313 self.token = token if token is not None else '' 8314 ''' 8315 The auth token generated for the Node. The Node will use this token to 8316 authenticate with the strongDM API. 8317 '''
#
meta
Reserved for future use.
#
node
The created Node.
#
rate_limit
Rate limit information.
#
token
The auth token generated for the Node. The Node will use this token to authenticate with the strongDM API.
View Source
8345class NodeDeleteResponse: 8346 ''' 8347 NodeDeleteResponse returns information about a Node that was deleted. 8348 ''' 8349 __slots__ = [ 8350 'meta', 8351 'rate_limit', 8352 ] 8353 8354 def __init__( 8355 self, 8356 meta=None, 8357 rate_limit=None, 8358 ): 8359 self.meta = meta if meta is not None else None 8360 ''' 8361 Reserved for future use. 8362 ''' 8363 self.rate_limit = rate_limit if rate_limit is not None else None 8364 ''' 8365 Rate limit information. 8366 ''' 8367 8368 def __repr__(self): 8369 return '<sdm.NodeDeleteResponse ' + \ 8370 'meta: ' + repr(self.meta) + ' ' +\ 8371 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 8372 '>' 8373 8374 def to_dict(self): 8375 return { 8376 'meta': self.meta, 8377 'rate_limit': self.rate_limit, 8378 } 8379 8380 @classmethod 8381 def from_dict(cls, d): 8382 return cls( 8383 meta=d.get('meta'), 8384 rate_limit=d.get('rate_limit'), 8385 )
NodeDeleteResponse returns information about a Node that was deleted.
View Source
#
meta
Reserved for future use.
#
rate_limit
Rate limit information.
View Source
8388class NodeGetResponse: 8389 ''' 8390 NodeGetResponse returns a requested Node. 8391 ''' 8392 __slots__ = [ 8393 'meta', 8394 'node', 8395 'rate_limit', 8396 ] 8397 8398 def __init__( 8399 self, 8400 meta=None, 8401 node=None, 8402 rate_limit=None, 8403 ): 8404 self.meta = meta if meta is not None else None 8405 ''' 8406 Reserved for future use. 8407 ''' 8408 self.node = node if node is not None else None 8409 ''' 8410 The requested Node. 8411 ''' 8412 self.rate_limit = rate_limit if rate_limit is not None else None 8413 ''' 8414 Rate limit information. 8415 ''' 8416 8417 def __repr__(self): 8418 return '<sdm.NodeGetResponse ' + \ 8419 'meta: ' + repr(self.meta) + ' ' +\ 8420 'node: ' + repr(self.node) + ' ' +\ 8421 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 8422 '>' 8423 8424 def to_dict(self): 8425 return { 8426 'meta': self.meta, 8427 'node': self.node, 8428 'rate_limit': self.rate_limit, 8429 } 8430 8431 @classmethod 8432 def from_dict(cls, d): 8433 return cls( 8434 meta=d.get('meta'), 8435 node=d.get('node'), 8436 rate_limit=d.get('rate_limit'), 8437 )
NodeGetResponse returns a requested Node.
View Source
8398 def __init__( 8399 self, 8400 meta=None, 8401 node=None, 8402 rate_limit=None, 8403 ): 8404 self.meta = meta if meta is not None else None 8405 ''' 8406 Reserved for future use. 8407 ''' 8408 self.node = node if node is not None else None 8409 ''' 8410 The requested Node. 8411 ''' 8412 self.rate_limit = rate_limit if rate_limit is not None else None 8413 ''' 8414 Rate limit information. 8415 '''
#
meta
Reserved for future use.
#
node
The requested Node.
#
rate_limit
Rate limit information.
View Source
8440class NodeUpdateResponse: 8441 ''' 8442 NodeUpdateResponse returns the fields of a Node after it has been updated by 8443 a NodeUpdateRequest. 8444 ''' 8445 __slots__ = [ 8446 'meta', 8447 'node', 8448 'rate_limit', 8449 ] 8450 8451 def __init__( 8452 self, 8453 meta=None, 8454 node=None, 8455 rate_limit=None, 8456 ): 8457 self.meta = meta if meta is not None else None 8458 ''' 8459 Reserved for future use. 8460 ''' 8461 self.node = node if node is not None else None 8462 ''' 8463 The updated Node. 8464 ''' 8465 self.rate_limit = rate_limit if rate_limit is not None else None 8466 ''' 8467 Rate limit information. 8468 ''' 8469 8470 def __repr__(self): 8471 return '<sdm.NodeUpdateResponse ' + \ 8472 'meta: ' + repr(self.meta) + ' ' +\ 8473 'node: ' + repr(self.node) + ' ' +\ 8474 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 8475 '>' 8476 8477 def to_dict(self): 8478 return { 8479 'meta': self.meta, 8480 'node': self.node, 8481 'rate_limit': self.rate_limit, 8482 } 8483 8484 @classmethod 8485 def from_dict(cls, d): 8486 return cls( 8487 meta=d.get('meta'), 8488 node=d.get('node'), 8489 rate_limit=d.get('rate_limit'), 8490 )
NodeUpdateResponse returns the fields of a Node after it has been updated by a NodeUpdateRequest.
View Source
8451 def __init__( 8452 self, 8453 meta=None, 8454 node=None, 8455 rate_limit=None, 8456 ): 8457 self.meta = meta if meta is not None else None 8458 ''' 8459 Reserved for future use. 8460 ''' 8461 self.node = node if node is not None else None 8462 ''' 8463 The updated Node. 8464 ''' 8465 self.rate_limit = rate_limit if rate_limit is not None else None 8466 ''' 8467 Rate limit information. 8468 '''
#
meta
Reserved for future use.
#
node
The updated Node.
#
rate_limit
Rate limit information.
View Source
8493class Oracle: 8494 ''' 8495 8496 ''' 8497 __slots__ = [ 8498 'database', 8499 'egress_filter', 8500 'healthy', 8501 'hostname', 8502 'id', 8503 'name', 8504 'password', 8505 'port', 8506 'port_override', 8507 'secret_store_id', 8508 'tags', 8509 'tls_required', 8510 'username', 8511 ] 8512 8513 def __init__( 8514 self, 8515 database=None, 8516 egress_filter=None, 8517 healthy=None, 8518 hostname=None, 8519 id=None, 8520 name=None, 8521 password=None, 8522 port=None, 8523 port_override=None, 8524 secret_store_id=None, 8525 tags=None, 8526 tls_required=None, 8527 username=None, 8528 ): 8529 self.database = database if database is not None else '' 8530 ''' 8531 8532 ''' 8533 self.egress_filter = egress_filter if egress_filter is not None else '' 8534 ''' 8535 A filter applied to the routing logic to pin datasource to nodes. 8536 ''' 8537 self.healthy = healthy if healthy is not None else False 8538 ''' 8539 True if the datasource is reachable and the credentials are valid. 8540 ''' 8541 self.hostname = hostname if hostname is not None else '' 8542 ''' 8543 8544 ''' 8545 self.id = id if id is not None else '' 8546 ''' 8547 Unique identifier of the Resource. 8548 ''' 8549 self.name = name if name is not None else '' 8550 ''' 8551 Unique human-readable name of the Resource. 8552 ''' 8553 self.password = password if password is not None else '' 8554 ''' 8555 8556 ''' 8557 self.port = port if port is not None else 0 8558 ''' 8559 8560 ''' 8561 self.port_override = port_override if port_override is not None else 0 8562 ''' 8563 8564 ''' 8565 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 8566 ''' 8567 ID of the secret store containing credentials for this resource, if any. 8568 ''' 8569 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 8570 ''' 8571 Tags is a map of key, value pairs. 8572 ''' 8573 self.tls_required = tls_required if tls_required is not None else False 8574 ''' 8575 8576 ''' 8577 self.username = username if username is not None else '' 8578 ''' 8579 8580 ''' 8581 8582 def __repr__(self): 8583 return '<sdm.Oracle ' + \ 8584 'database: ' + repr(self.database) + ' ' +\ 8585 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 8586 'healthy: ' + repr(self.healthy) + ' ' +\ 8587 'hostname: ' + repr(self.hostname) + ' ' +\ 8588 'id: ' + repr(self.id) + ' ' +\ 8589 'name: ' + repr(self.name) + ' ' +\ 8590 'password: ' + repr(self.password) + ' ' +\ 8591 'port: ' + repr(self.port) + ' ' +\ 8592 'port_override: ' + repr(self.port_override) + ' ' +\ 8593 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 8594 'tags: ' + repr(self.tags) + ' ' +\ 8595 'tls_required: ' + repr(self.tls_required) + ' ' +\ 8596 'username: ' + repr(self.username) + ' ' +\ 8597 '>' 8598 8599 def to_dict(self): 8600 return { 8601 'database': self.database, 8602 'egress_filter': self.egress_filter, 8603 'healthy': self.healthy, 8604 'hostname': self.hostname, 8605 'id': self.id, 8606 'name': self.name, 8607 'password': self.password, 8608 'port': self.port, 8609 'port_override': self.port_override, 8610 'secret_store_id': self.secret_store_id, 8611 'tags': self.tags, 8612 'tls_required': self.tls_required, 8613 'username': self.username, 8614 } 8615 8616 @classmethod 8617 def from_dict(cls, d): 8618 return cls( 8619 database=d.get('database'), 8620 egress_filter=d.get('egress_filter'), 8621 healthy=d.get('healthy'), 8622 hostname=d.get('hostname'), 8623 id=d.get('id'), 8624 name=d.get('name'), 8625 password=d.get('password'), 8626 port=d.get('port'), 8627 port_override=d.get('port_override'), 8628 secret_store_id=d.get('secret_store_id'), 8629 tags=d.get('tags'), 8630 tls_required=d.get('tls_required'), 8631 username=d.get('username'), 8632 )
#
Oracle(
database=None,
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
password=None,
port=None,
port_override=None,
secret_store_id=None,
tags=None,
tls_required=None,
username=None
)
View Source
8513 def __init__( 8514 self, 8515 database=None, 8516 egress_filter=None, 8517 healthy=None, 8518 hostname=None, 8519 id=None, 8520 name=None, 8521 password=None, 8522 port=None, 8523 port_override=None, 8524 secret_store_id=None, 8525 tags=None, 8526 tls_required=None, 8527 username=None, 8528 ): 8529 self.database = database if database is not None else '' 8530 ''' 8531 8532 ''' 8533 self.egress_filter = egress_filter if egress_filter is not None else '' 8534 ''' 8535 A filter applied to the routing logic to pin datasource to nodes. 8536 ''' 8537 self.healthy = healthy if healthy is not None else False 8538 ''' 8539 True if the datasource is reachable and the credentials are valid. 8540 ''' 8541 self.hostname = hostname if hostname is not None else '' 8542 ''' 8543 8544 ''' 8545 self.id = id if id is not None else '' 8546 ''' 8547 Unique identifier of the Resource. 8548 ''' 8549 self.name = name if name is not None else '' 8550 ''' 8551 Unique human-readable name of the Resource. 8552 ''' 8553 self.password = password if password is not None else '' 8554 ''' 8555 8556 ''' 8557 self.port = port if port is not None else 0 8558 ''' 8559 8560 ''' 8561 self.port_override = port_override if port_override is not None else 0 8562 ''' 8563 8564 ''' 8565 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 8566 ''' 8567 ID of the secret store containing credentials for this resource, if any. 8568 ''' 8569 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 8570 ''' 8571 Tags is a map of key, value pairs. 8572 ''' 8573 self.tls_required = tls_required if tls_required is not None else False 8574 ''' 8575 8576 ''' 8577 self.username = username if username is not None else '' 8578 ''' 8579 8580 '''
#
database
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
password
#
port
#
port_override
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
tls_required
#
username
View Source
8599 def to_dict(self): 8600 return { 8601 'database': self.database, 8602 'egress_filter': self.egress_filter, 8603 'healthy': self.healthy, 8604 'hostname': self.hostname, 8605 'id': self.id, 8606 'name': self.name, 8607 'password': self.password, 8608 'port': self.port, 8609 'port_override': self.port_override, 8610 'secret_store_id': self.secret_store_id, 8611 'tags': self.tags, 8612 'tls_required': self.tls_required, 8613 'username': self.username, 8614 }
View Source
8616 @classmethod 8617 def from_dict(cls, d): 8618 return cls( 8619 database=d.get('database'), 8620 egress_filter=d.get('egress_filter'), 8621 healthy=d.get('healthy'), 8622 hostname=d.get('hostname'), 8623 id=d.get('id'), 8624 name=d.get('name'), 8625 password=d.get('password'), 8626 port=d.get('port'), 8627 port_override=d.get('port_override'), 8628 secret_store_id=d.get('secret_store_id'), 8629 tags=d.get('tags'), 8630 tls_required=d.get('tls_required'), 8631 username=d.get('username'), 8632 )
View Source
8635class Postgres: 8636 ''' 8637 8638 ''' 8639 __slots__ = [ 8640 'database', 8641 'egress_filter', 8642 'healthy', 8643 'hostname', 8644 'id', 8645 'name', 8646 'override_database', 8647 'password', 8648 'port', 8649 'port_override', 8650 'secret_store_id', 8651 'tags', 8652 'username', 8653 ] 8654 8655 def __init__( 8656 self, 8657 database=None, 8658 egress_filter=None, 8659 healthy=None, 8660 hostname=None, 8661 id=None, 8662 name=None, 8663 override_database=None, 8664 password=None, 8665 port=None, 8666 port_override=None, 8667 secret_store_id=None, 8668 tags=None, 8669 username=None, 8670 ): 8671 self.database = database if database is not None else '' 8672 ''' 8673 8674 ''' 8675 self.egress_filter = egress_filter if egress_filter is not None else '' 8676 ''' 8677 A filter applied to the routing logic to pin datasource to nodes. 8678 ''' 8679 self.healthy = healthy if healthy is not None else False 8680 ''' 8681 True if the datasource is reachable and the credentials are valid. 8682 ''' 8683 self.hostname = hostname if hostname is not None else '' 8684 ''' 8685 8686 ''' 8687 self.id = id if id is not None else '' 8688 ''' 8689 Unique identifier of the Resource. 8690 ''' 8691 self.name = name if name is not None else '' 8692 ''' 8693 Unique human-readable name of the Resource. 8694 ''' 8695 self.override_database = override_database if override_database is not None else False 8696 ''' 8697 8698 ''' 8699 self.password = password if password is not None else '' 8700 ''' 8701 8702 ''' 8703 self.port = port if port is not None else 0 8704 ''' 8705 8706 ''' 8707 self.port_override = port_override if port_override is not None else 0 8708 ''' 8709 8710 ''' 8711 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 8712 ''' 8713 ID of the secret store containing credentials for this resource, if any. 8714 ''' 8715 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 8716 ''' 8717 Tags is a map of key, value pairs. 8718 ''' 8719 self.username = username if username is not None else '' 8720 ''' 8721 8722 ''' 8723 8724 def __repr__(self): 8725 return '<sdm.Postgres ' + \ 8726 'database: ' + repr(self.database) + ' ' +\ 8727 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 8728 'healthy: ' + repr(self.healthy) + ' ' +\ 8729 'hostname: ' + repr(self.hostname) + ' ' +\ 8730 'id: ' + repr(self.id) + ' ' +\ 8731 'name: ' + repr(self.name) + ' ' +\ 8732 'override_database: ' + repr(self.override_database) + ' ' +\ 8733 'password: ' + repr(self.password) + ' ' +\ 8734 'port: ' + repr(self.port) + ' ' +\ 8735 'port_override: ' + repr(self.port_override) + ' ' +\ 8736 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 8737 'tags: ' + repr(self.tags) + ' ' +\ 8738 'username: ' + repr(self.username) + ' ' +\ 8739 '>' 8740 8741 def to_dict(self): 8742 return { 8743 'database': self.database, 8744 'egress_filter': self.egress_filter, 8745 'healthy': self.healthy, 8746 'hostname': self.hostname, 8747 'id': self.id, 8748 'name': self.name, 8749 'override_database': self.override_database, 8750 'password': self.password, 8751 'port': self.port, 8752 'port_override': self.port_override, 8753 'secret_store_id': self.secret_store_id, 8754 'tags': self.tags, 8755 'username': self.username, 8756 } 8757 8758 @classmethod 8759 def from_dict(cls, d): 8760 return cls( 8761 database=d.get('database'), 8762 egress_filter=d.get('egress_filter'), 8763 healthy=d.get('healthy'), 8764 hostname=d.get('hostname'), 8765 id=d.get('id'), 8766 name=d.get('name'), 8767 override_database=d.get('override_database'), 8768 password=d.get('password'), 8769 port=d.get('port'), 8770 port_override=d.get('port_override'), 8771 secret_store_id=d.get('secret_store_id'), 8772 tags=d.get('tags'), 8773 username=d.get('username'), 8774 )
#
Postgres(
database=None,
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
override_database=None,
password=None,
port=None,
port_override=None,
secret_store_id=None,
tags=None,
username=None
)
View Source
8655 def __init__( 8656 self, 8657 database=None, 8658 egress_filter=None, 8659 healthy=None, 8660 hostname=None, 8661 id=None, 8662 name=None, 8663 override_database=None, 8664 password=None, 8665 port=None, 8666 port_override=None, 8667 secret_store_id=None, 8668 tags=None, 8669 username=None, 8670 ): 8671 self.database = database if database is not None else '' 8672 ''' 8673 8674 ''' 8675 self.egress_filter = egress_filter if egress_filter is not None else '' 8676 ''' 8677 A filter applied to the routing logic to pin datasource to nodes. 8678 ''' 8679 self.healthy = healthy if healthy is not None else False 8680 ''' 8681 True if the datasource is reachable and the credentials are valid. 8682 ''' 8683 self.hostname = hostname if hostname is not None else '' 8684 ''' 8685 8686 ''' 8687 self.id = id if id is not None else '' 8688 ''' 8689 Unique identifier of the Resource. 8690 ''' 8691 self.name = name if name is not None else '' 8692 ''' 8693 Unique human-readable name of the Resource. 8694 ''' 8695 self.override_database = override_database if override_database is not None else False 8696 ''' 8697 8698 ''' 8699 self.password = password if password is not None else '' 8700 ''' 8701 8702 ''' 8703 self.port = port if port is not None else 0 8704 ''' 8705 8706 ''' 8707 self.port_override = port_override if port_override is not None else 0 8708 ''' 8709 8710 ''' 8711 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 8712 ''' 8713 ID of the secret store containing credentials for this resource, if any. 8714 ''' 8715 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 8716 ''' 8717 Tags is a map of key, value pairs. 8718 ''' 8719 self.username = username if username is not None else '' 8720 ''' 8721 8722 '''
#
database
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
override_database
#
password
#
port
#
port_override
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
username
View Source
8741 def to_dict(self): 8742 return { 8743 'database': self.database, 8744 'egress_filter': self.egress_filter, 8745 'healthy': self.healthy, 8746 'hostname': self.hostname, 8747 'id': self.id, 8748 'name': self.name, 8749 'override_database': self.override_database, 8750 'password': self.password, 8751 'port': self.port, 8752 'port_override': self.port_override, 8753 'secret_store_id': self.secret_store_id, 8754 'tags': self.tags, 8755 'username': self.username, 8756 }
View Source
8758 @classmethod 8759 def from_dict(cls, d): 8760 return cls( 8761 database=d.get('database'), 8762 egress_filter=d.get('egress_filter'), 8763 healthy=d.get('healthy'), 8764 hostname=d.get('hostname'), 8765 id=d.get('id'), 8766 name=d.get('name'), 8767 override_database=d.get('override_database'), 8768 password=d.get('password'), 8769 port=d.get('port'), 8770 port_override=d.get('port_override'), 8771 secret_store_id=d.get('secret_store_id'), 8772 tags=d.get('tags'), 8773 username=d.get('username'), 8774 )
View Source
8777class Presto: 8778 ''' 8779 8780 ''' 8781 __slots__ = [ 8782 'database', 8783 'egress_filter', 8784 'healthy', 8785 'hostname', 8786 'id', 8787 'name', 8788 'password', 8789 'port', 8790 'port_override', 8791 'secret_store_id', 8792 'tags', 8793 'tls_required', 8794 'username', 8795 ] 8796 8797 def __init__( 8798 self, 8799 database=None, 8800 egress_filter=None, 8801 healthy=None, 8802 hostname=None, 8803 id=None, 8804 name=None, 8805 password=None, 8806 port=None, 8807 port_override=None, 8808 secret_store_id=None, 8809 tags=None, 8810 tls_required=None, 8811 username=None, 8812 ): 8813 self.database = database if database is not None else '' 8814 ''' 8815 8816 ''' 8817 self.egress_filter = egress_filter if egress_filter is not None else '' 8818 ''' 8819 A filter applied to the routing logic to pin datasource to nodes. 8820 ''' 8821 self.healthy = healthy if healthy is not None else False 8822 ''' 8823 True if the datasource is reachable and the credentials are valid. 8824 ''' 8825 self.hostname = hostname if hostname is not None else '' 8826 ''' 8827 8828 ''' 8829 self.id = id if id is not None else '' 8830 ''' 8831 Unique identifier of the Resource. 8832 ''' 8833 self.name = name if name is not None else '' 8834 ''' 8835 Unique human-readable name of the Resource. 8836 ''' 8837 self.password = password if password is not None else '' 8838 ''' 8839 8840 ''' 8841 self.port = port if port is not None else 0 8842 ''' 8843 8844 ''' 8845 self.port_override = port_override if port_override is not None else 0 8846 ''' 8847 8848 ''' 8849 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 8850 ''' 8851 ID of the secret store containing credentials for this resource, if any. 8852 ''' 8853 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 8854 ''' 8855 Tags is a map of key, value pairs. 8856 ''' 8857 self.tls_required = tls_required if tls_required is not None else False 8858 ''' 8859 8860 ''' 8861 self.username = username if username is not None else '' 8862 ''' 8863 8864 ''' 8865 8866 def __repr__(self): 8867 return '<sdm.Presto ' + \ 8868 'database: ' + repr(self.database) + ' ' +\ 8869 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 8870 'healthy: ' + repr(self.healthy) + ' ' +\ 8871 'hostname: ' + repr(self.hostname) + ' ' +\ 8872 'id: ' + repr(self.id) + ' ' +\ 8873 'name: ' + repr(self.name) + ' ' +\ 8874 'password: ' + repr(self.password) + ' ' +\ 8875 'port: ' + repr(self.port) + ' ' +\ 8876 'port_override: ' + repr(self.port_override) + ' ' +\ 8877 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 8878 'tags: ' + repr(self.tags) + ' ' +\ 8879 'tls_required: ' + repr(self.tls_required) + ' ' +\ 8880 'username: ' + repr(self.username) + ' ' +\ 8881 '>' 8882 8883 def to_dict(self): 8884 return { 8885 'database': self.database, 8886 'egress_filter': self.egress_filter, 8887 'healthy': self.healthy, 8888 'hostname': self.hostname, 8889 'id': self.id, 8890 'name': self.name, 8891 'password': self.password, 8892 'port': self.port, 8893 'port_override': self.port_override, 8894 'secret_store_id': self.secret_store_id, 8895 'tags': self.tags, 8896 'tls_required': self.tls_required, 8897 'username': self.username, 8898 } 8899 8900 @classmethod 8901 def from_dict(cls, d): 8902 return cls( 8903 database=d.get('database'), 8904 egress_filter=d.get('egress_filter'), 8905 healthy=d.get('healthy'), 8906 hostname=d.get('hostname'), 8907 id=d.get('id'), 8908 name=d.get('name'), 8909 password=d.get('password'), 8910 port=d.get('port'), 8911 port_override=d.get('port_override'), 8912 secret_store_id=d.get('secret_store_id'), 8913 tags=d.get('tags'), 8914 tls_required=d.get('tls_required'), 8915 username=d.get('username'), 8916 )
#
Presto(
database=None,
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
password=None,
port=None,
port_override=None,
secret_store_id=None,
tags=None,
tls_required=None,
username=None
)
View Source
8797 def __init__( 8798 self, 8799 database=None, 8800 egress_filter=None, 8801 healthy=None, 8802 hostname=None, 8803 id=None, 8804 name=None, 8805 password=None, 8806 port=None, 8807 port_override=None, 8808 secret_store_id=None, 8809 tags=None, 8810 tls_required=None, 8811 username=None, 8812 ): 8813 self.database = database if database is not None else '' 8814 ''' 8815 8816 ''' 8817 self.egress_filter = egress_filter if egress_filter is not None else '' 8818 ''' 8819 A filter applied to the routing logic to pin datasource to nodes. 8820 ''' 8821 self.healthy = healthy if healthy is not None else False 8822 ''' 8823 True if the datasource is reachable and the credentials are valid. 8824 ''' 8825 self.hostname = hostname if hostname is not None else '' 8826 ''' 8827 8828 ''' 8829 self.id = id if id is not None else '' 8830 ''' 8831 Unique identifier of the Resource. 8832 ''' 8833 self.name = name if name is not None else '' 8834 ''' 8835 Unique human-readable name of the Resource. 8836 ''' 8837 self.password = password if password is not None else '' 8838 ''' 8839 8840 ''' 8841 self.port = port if port is not None else 0 8842 ''' 8843 8844 ''' 8845 self.port_override = port_override if port_override is not None else 0 8846 ''' 8847 8848 ''' 8849 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 8850 ''' 8851 ID of the secret store containing credentials for this resource, if any. 8852 ''' 8853 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 8854 ''' 8855 Tags is a map of key, value pairs. 8856 ''' 8857 self.tls_required = tls_required if tls_required is not None else False 8858 ''' 8859 8860 ''' 8861 self.username = username if username is not None else '' 8862 ''' 8863 8864 '''
#
database
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
password
#
port
#
port_override
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
tls_required
#
username
View Source
8883 def to_dict(self): 8884 return { 8885 'database': self.database, 8886 'egress_filter': self.egress_filter, 8887 'healthy': self.healthy, 8888 'hostname': self.hostname, 8889 'id': self.id, 8890 'name': self.name, 8891 'password': self.password, 8892 'port': self.port, 8893 'port_override': self.port_override, 8894 'secret_store_id': self.secret_store_id, 8895 'tags': self.tags, 8896 'tls_required': self.tls_required, 8897 'username': self.username, 8898 }
View Source
8900 @classmethod 8901 def from_dict(cls, d): 8902 return cls( 8903 database=d.get('database'), 8904 egress_filter=d.get('egress_filter'), 8905 healthy=d.get('healthy'), 8906 hostname=d.get('hostname'), 8907 id=d.get('id'), 8908 name=d.get('name'), 8909 password=d.get('password'), 8910 port=d.get('port'), 8911 port_override=d.get('port_override'), 8912 secret_store_id=d.get('secret_store_id'), 8913 tags=d.get('tags'), 8914 tls_required=d.get('tls_required'), 8915 username=d.get('username'), 8916 )
View Source
8919class RDP: 8920 ''' 8921 8922 ''' 8923 __slots__ = [ 8924 'downgrade_nla_connections', 8925 'egress_filter', 8926 'healthy', 8927 'hostname', 8928 'id', 8929 'name', 8930 'password', 8931 'port', 8932 'port_override', 8933 'secret_store_id', 8934 'tags', 8935 'username', 8936 ] 8937 8938 def __init__( 8939 self, 8940 downgrade_nla_connections=None, 8941 egress_filter=None, 8942 healthy=None, 8943 hostname=None, 8944 id=None, 8945 name=None, 8946 password=None, 8947 port=None, 8948 port_override=None, 8949 secret_store_id=None, 8950 tags=None, 8951 username=None, 8952 ): 8953 self.downgrade_nla_connections = downgrade_nla_connections if downgrade_nla_connections is not None else False 8954 ''' 8955 8956 ''' 8957 self.egress_filter = egress_filter if egress_filter is not None else '' 8958 ''' 8959 A filter applied to the routing logic to pin datasource to nodes. 8960 ''' 8961 self.healthy = healthy if healthy is not None else False 8962 ''' 8963 True if the datasource is reachable and the credentials are valid. 8964 ''' 8965 self.hostname = hostname if hostname is not None else '' 8966 ''' 8967 8968 ''' 8969 self.id = id if id is not None else '' 8970 ''' 8971 Unique identifier of the Resource. 8972 ''' 8973 self.name = name if name is not None else '' 8974 ''' 8975 Unique human-readable name of the Resource. 8976 ''' 8977 self.password = password if password is not None else '' 8978 ''' 8979 8980 ''' 8981 self.port = port if port is not None else 0 8982 ''' 8983 8984 ''' 8985 self.port_override = port_override if port_override is not None else 0 8986 ''' 8987 8988 ''' 8989 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 8990 ''' 8991 ID of the secret store containing credentials for this resource, if any. 8992 ''' 8993 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 8994 ''' 8995 Tags is a map of key, value pairs. 8996 ''' 8997 self.username = username if username is not None else '' 8998 ''' 8999 9000 ''' 9001 9002 def __repr__(self): 9003 return '<sdm.RDP ' + \ 9004 'downgrade_nla_connections: ' + repr(self.downgrade_nla_connections) + ' ' +\ 9005 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 9006 'healthy: ' + repr(self.healthy) + ' ' +\ 9007 'hostname: ' + repr(self.hostname) + ' ' +\ 9008 'id: ' + repr(self.id) + ' ' +\ 9009 'name: ' + repr(self.name) + ' ' +\ 9010 'password: ' + repr(self.password) + ' ' +\ 9011 'port: ' + repr(self.port) + ' ' +\ 9012 'port_override: ' + repr(self.port_override) + ' ' +\ 9013 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 9014 'tags: ' + repr(self.tags) + ' ' +\ 9015 'username: ' + repr(self.username) + ' ' +\ 9016 '>' 9017 9018 def to_dict(self): 9019 return { 9020 'downgrade_nla_connections': self.downgrade_nla_connections, 9021 'egress_filter': self.egress_filter, 9022 'healthy': self.healthy, 9023 'hostname': self.hostname, 9024 'id': self.id, 9025 'name': self.name, 9026 'password': self.password, 9027 'port': self.port, 9028 'port_override': self.port_override, 9029 'secret_store_id': self.secret_store_id, 9030 'tags': self.tags, 9031 'username': self.username, 9032 } 9033 9034 @classmethod 9035 def from_dict(cls, d): 9036 return cls( 9037 downgrade_nla_connections=d.get('downgrade_nla_connections'), 9038 egress_filter=d.get('egress_filter'), 9039 healthy=d.get('healthy'), 9040 hostname=d.get('hostname'), 9041 id=d.get('id'), 9042 name=d.get('name'), 9043 password=d.get('password'), 9044 port=d.get('port'), 9045 port_override=d.get('port_override'), 9046 secret_store_id=d.get('secret_store_id'), 9047 tags=d.get('tags'), 9048 username=d.get('username'), 9049 )
#
RDP(
downgrade_nla_connections=None,
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
password=None,
port=None,
port_override=None,
secret_store_id=None,
tags=None,
username=None
)
View Source
8938 def __init__( 8939 self, 8940 downgrade_nla_connections=None, 8941 egress_filter=None, 8942 healthy=None, 8943 hostname=None, 8944 id=None, 8945 name=None, 8946 password=None, 8947 port=None, 8948 port_override=None, 8949 secret_store_id=None, 8950 tags=None, 8951 username=None, 8952 ): 8953 self.downgrade_nla_connections = downgrade_nla_connections if downgrade_nla_connections is not None else False 8954 ''' 8955 8956 ''' 8957 self.egress_filter = egress_filter if egress_filter is not None else '' 8958 ''' 8959 A filter applied to the routing logic to pin datasource to nodes. 8960 ''' 8961 self.healthy = healthy if healthy is not None else False 8962 ''' 8963 True if the datasource is reachable and the credentials are valid. 8964 ''' 8965 self.hostname = hostname if hostname is not None else '' 8966 ''' 8967 8968 ''' 8969 self.id = id if id is not None else '' 8970 ''' 8971 Unique identifier of the Resource. 8972 ''' 8973 self.name = name if name is not None else '' 8974 ''' 8975 Unique human-readable name of the Resource. 8976 ''' 8977 self.password = password if password is not None else '' 8978 ''' 8979 8980 ''' 8981 self.port = port if port is not None else 0 8982 ''' 8983 8984 ''' 8985 self.port_override = port_override if port_override is not None else 0 8986 ''' 8987 8988 ''' 8989 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 8990 ''' 8991 ID of the secret store containing credentials for this resource, if any. 8992 ''' 8993 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 8994 ''' 8995 Tags is a map of key, value pairs. 8996 ''' 8997 self.username = username if username is not None else '' 8998 ''' 8999 9000 '''
#
downgrade_nla_connections
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
password
#
port
#
port_override
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
username
View Source
9018 def to_dict(self): 9019 return { 9020 'downgrade_nla_connections': self.downgrade_nla_connections, 9021 'egress_filter': self.egress_filter, 9022 'healthy': self.healthy, 9023 'hostname': self.hostname, 9024 'id': self.id, 9025 'name': self.name, 9026 'password': self.password, 9027 'port': self.port, 9028 'port_override': self.port_override, 9029 'secret_store_id': self.secret_store_id, 9030 'tags': self.tags, 9031 'username': self.username, 9032 }
View Source
9034 @classmethod 9035 def from_dict(cls, d): 9036 return cls( 9037 downgrade_nla_connections=d.get('downgrade_nla_connections'), 9038 egress_filter=d.get('egress_filter'), 9039 healthy=d.get('healthy'), 9040 hostname=d.get('hostname'), 9041 id=d.get('id'), 9042 name=d.get('name'), 9043 password=d.get('password'), 9044 port=d.get('port'), 9045 port_override=d.get('port_override'), 9046 secret_store_id=d.get('secret_store_id'), 9047 tags=d.get('tags'), 9048 username=d.get('username'), 9049 )
View Source
9052class RabbitMQAMQP091: 9053 ''' 9054 9055 ''' 9056 __slots__ = [ 9057 'egress_filter', 9058 'healthy', 9059 'hostname', 9060 'id', 9061 'name', 9062 'password', 9063 'port', 9064 'port_override', 9065 'secret_store_id', 9066 'tags', 9067 'tls_required', 9068 'username', 9069 ] 9070 9071 def __init__( 9072 self, 9073 egress_filter=None, 9074 healthy=None, 9075 hostname=None, 9076 id=None, 9077 name=None, 9078 password=None, 9079 port=None, 9080 port_override=None, 9081 secret_store_id=None, 9082 tags=None, 9083 tls_required=None, 9084 username=None, 9085 ): 9086 self.egress_filter = egress_filter if egress_filter is not None else '' 9087 ''' 9088 A filter applied to the routing logic to pin datasource to nodes. 9089 ''' 9090 self.healthy = healthy if healthy is not None else False 9091 ''' 9092 True if the datasource is reachable and the credentials are valid. 9093 ''' 9094 self.hostname = hostname if hostname is not None else '' 9095 ''' 9096 9097 ''' 9098 self.id = id if id is not None else '' 9099 ''' 9100 Unique identifier of the Resource. 9101 ''' 9102 self.name = name if name is not None else '' 9103 ''' 9104 Unique human-readable name of the Resource. 9105 ''' 9106 self.password = password if password is not None else '' 9107 ''' 9108 9109 ''' 9110 self.port = port if port is not None else 0 9111 ''' 9112 9113 ''' 9114 self.port_override = port_override if port_override is not None else 0 9115 ''' 9116 9117 ''' 9118 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 9119 ''' 9120 ID of the secret store containing credentials for this resource, if any. 9121 ''' 9122 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 9123 ''' 9124 Tags is a map of key, value pairs. 9125 ''' 9126 self.tls_required = tls_required if tls_required is not None else False 9127 ''' 9128 9129 ''' 9130 self.username = username if username is not None else '' 9131 ''' 9132 9133 ''' 9134 9135 def __repr__(self): 9136 return '<sdm.RabbitMQAMQP091 ' + \ 9137 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 9138 'healthy: ' + repr(self.healthy) + ' ' +\ 9139 'hostname: ' + repr(self.hostname) + ' ' +\ 9140 'id: ' + repr(self.id) + ' ' +\ 9141 'name: ' + repr(self.name) + ' ' +\ 9142 'password: ' + repr(self.password) + ' ' +\ 9143 'port: ' + repr(self.port) + ' ' +\ 9144 'port_override: ' + repr(self.port_override) + ' ' +\ 9145 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 9146 'tags: ' + repr(self.tags) + ' ' +\ 9147 'tls_required: ' + repr(self.tls_required) + ' ' +\ 9148 'username: ' + repr(self.username) + ' ' +\ 9149 '>' 9150 9151 def to_dict(self): 9152 return { 9153 'egress_filter': self.egress_filter, 9154 'healthy': self.healthy, 9155 'hostname': self.hostname, 9156 'id': self.id, 9157 'name': self.name, 9158 'password': self.password, 9159 'port': self.port, 9160 'port_override': self.port_override, 9161 'secret_store_id': self.secret_store_id, 9162 'tags': self.tags, 9163 'tls_required': self.tls_required, 9164 'username': self.username, 9165 } 9166 9167 @classmethod 9168 def from_dict(cls, d): 9169 return cls( 9170 egress_filter=d.get('egress_filter'), 9171 healthy=d.get('healthy'), 9172 hostname=d.get('hostname'), 9173 id=d.get('id'), 9174 name=d.get('name'), 9175 password=d.get('password'), 9176 port=d.get('port'), 9177 port_override=d.get('port_override'), 9178 secret_store_id=d.get('secret_store_id'), 9179 tags=d.get('tags'), 9180 tls_required=d.get('tls_required'), 9181 username=d.get('username'), 9182 )
#
RabbitMQAMQP091(
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
password=None,
port=None,
port_override=None,
secret_store_id=None,
tags=None,
tls_required=None,
username=None
)
View Source
9071 def __init__( 9072 self, 9073 egress_filter=None, 9074 healthy=None, 9075 hostname=None, 9076 id=None, 9077 name=None, 9078 password=None, 9079 port=None, 9080 port_override=None, 9081 secret_store_id=None, 9082 tags=None, 9083 tls_required=None, 9084 username=None, 9085 ): 9086 self.egress_filter = egress_filter if egress_filter is not None else '' 9087 ''' 9088 A filter applied to the routing logic to pin datasource to nodes. 9089 ''' 9090 self.healthy = healthy if healthy is not None else False 9091 ''' 9092 True if the datasource is reachable and the credentials are valid. 9093 ''' 9094 self.hostname = hostname if hostname is not None else '' 9095 ''' 9096 9097 ''' 9098 self.id = id if id is not None else '' 9099 ''' 9100 Unique identifier of the Resource. 9101 ''' 9102 self.name = name if name is not None else '' 9103 ''' 9104 Unique human-readable name of the Resource. 9105 ''' 9106 self.password = password if password is not None else '' 9107 ''' 9108 9109 ''' 9110 self.port = port if port is not None else 0 9111 ''' 9112 9113 ''' 9114 self.port_override = port_override if port_override is not None else 0 9115 ''' 9116 9117 ''' 9118 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 9119 ''' 9120 ID of the secret store containing credentials for this resource, if any. 9121 ''' 9122 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 9123 ''' 9124 Tags is a map of key, value pairs. 9125 ''' 9126 self.tls_required = tls_required if tls_required is not None else False 9127 ''' 9128 9129 ''' 9130 self.username = username if username is not None else '' 9131 ''' 9132 9133 '''
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
password
#
port
#
port_override
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
tls_required
#
username
View Source
9151 def to_dict(self): 9152 return { 9153 'egress_filter': self.egress_filter, 9154 'healthy': self.healthy, 9155 'hostname': self.hostname, 9156 'id': self.id, 9157 'name': self.name, 9158 'password': self.password, 9159 'port': self.port, 9160 'port_override': self.port_override, 9161 'secret_store_id': self.secret_store_id, 9162 'tags': self.tags, 9163 'tls_required': self.tls_required, 9164 'username': self.username, 9165 }
View Source
9167 @classmethod 9168 def from_dict(cls, d): 9169 return cls( 9170 egress_filter=d.get('egress_filter'), 9171 healthy=d.get('healthy'), 9172 hostname=d.get('hostname'), 9173 id=d.get('id'), 9174 name=d.get('name'), 9175 password=d.get('password'), 9176 port=d.get('port'), 9177 port_override=d.get('port_override'), 9178 secret_store_id=d.get('secret_store_id'), 9179 tags=d.get('tags'), 9180 tls_required=d.get('tls_required'), 9181 username=d.get('username'), 9182 )
View Source
9185class RateLimitMetadata: 9186 ''' 9187 RateLimitMetadata contains information about remaining requests avaialable 9188 to the user over some timeframe. 9189 ''' 9190 __slots__ = [ 9191 'bucket', 9192 'limit', 9193 'remaining', 9194 'reset_at', 9195 ] 9196 9197 def __init__( 9198 self, 9199 bucket=None, 9200 limit=None, 9201 remaining=None, 9202 reset_at=None, 9203 ): 9204 self.bucket = bucket if bucket is not None else '' 9205 ''' 9206 The bucket this user/token is associated with, which may be shared between 9207 multiple users/tokens. 9208 ''' 9209 self.limit = limit if limit is not None else 0 9210 ''' 9211 How many total requests the user/token is authorized to make before being 9212 rate limited. 9213 ''' 9214 self.remaining = remaining if remaining is not None else 0 9215 ''' 9216 How many remaining requests out of the limit are still avaialable. 9217 ''' 9218 self.reset_at = reset_at if reset_at is not None else None 9219 ''' 9220 The time when remaining will be reset to limit. 9221 ''' 9222 9223 def __repr__(self): 9224 return '<sdm.RateLimitMetadata ' + \ 9225 'bucket: ' + repr(self.bucket) + ' ' +\ 9226 'limit: ' + repr(self.limit) + ' ' +\ 9227 'remaining: ' + repr(self.remaining) + ' ' +\ 9228 'reset_at: ' + repr(self.reset_at) + ' ' +\ 9229 '>' 9230 9231 def to_dict(self): 9232 return { 9233 'bucket': self.bucket, 9234 'limit': self.limit, 9235 'remaining': self.remaining, 9236 'reset_at': self.reset_at, 9237 } 9238 9239 @classmethod 9240 def from_dict(cls, d): 9241 return cls( 9242 bucket=d.get('bucket'), 9243 limit=d.get('limit'), 9244 remaining=d.get('remaining'), 9245 reset_at=d.get('reset_at'), 9246 )
RateLimitMetadata contains information about remaining requests avaialable to the user over some timeframe.
View Source
9197 def __init__( 9198 self, 9199 bucket=None, 9200 limit=None, 9201 remaining=None, 9202 reset_at=None, 9203 ): 9204 self.bucket = bucket if bucket is not None else '' 9205 ''' 9206 The bucket this user/token is associated with, which may be shared between 9207 multiple users/tokens. 9208 ''' 9209 self.limit = limit if limit is not None else 0 9210 ''' 9211 How many total requests the user/token is authorized to make before being 9212 rate limited. 9213 ''' 9214 self.remaining = remaining if remaining is not None else 0 9215 ''' 9216 How many remaining requests out of the limit are still avaialable. 9217 ''' 9218 self.reset_at = reset_at if reset_at is not None else None 9219 ''' 9220 The time when remaining will be reset to limit. 9221 '''
#
bucket
The bucket this user/token is associated with, which may be shared between multiple users/tokens.
#
limit
How many total requests the user/token is authorized to make before being rate limited.
#
remaining
How many remaining requests out of the limit are still avaialable.
#
reset_at
The time when remaining will be reset to limit.
View Source
9249class RawTCP: 9250 ''' 9251 9252 ''' 9253 __slots__ = [ 9254 'egress_filter', 9255 'healthy', 9256 'hostname', 9257 'id', 9258 'name', 9259 'port', 9260 'port_override', 9261 'secret_store_id', 9262 'tags', 9263 ] 9264 9265 def __init__( 9266 self, 9267 egress_filter=None, 9268 healthy=None, 9269 hostname=None, 9270 id=None, 9271 name=None, 9272 port=None, 9273 port_override=None, 9274 secret_store_id=None, 9275 tags=None, 9276 ): 9277 self.egress_filter = egress_filter if egress_filter is not None else '' 9278 ''' 9279 A filter applied to the routing logic to pin datasource to nodes. 9280 ''' 9281 self.healthy = healthy if healthy is not None else False 9282 ''' 9283 True if the datasource is reachable and the credentials are valid. 9284 ''' 9285 self.hostname = hostname if hostname is not None else '' 9286 ''' 9287 9288 ''' 9289 self.id = id if id is not None else '' 9290 ''' 9291 Unique identifier of the Resource. 9292 ''' 9293 self.name = name if name is not None else '' 9294 ''' 9295 Unique human-readable name of the Resource. 9296 ''' 9297 self.port = port if port is not None else 0 9298 ''' 9299 9300 ''' 9301 self.port_override = port_override if port_override is not None else 0 9302 ''' 9303 9304 ''' 9305 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 9306 ''' 9307 ID of the secret store containing credentials for this resource, if any. 9308 ''' 9309 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 9310 ''' 9311 Tags is a map of key, value pairs. 9312 ''' 9313 9314 def __repr__(self): 9315 return '<sdm.RawTCP ' + \ 9316 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 9317 'healthy: ' + repr(self.healthy) + ' ' +\ 9318 'hostname: ' + repr(self.hostname) + ' ' +\ 9319 'id: ' + repr(self.id) + ' ' +\ 9320 'name: ' + repr(self.name) + ' ' +\ 9321 'port: ' + repr(self.port) + ' ' +\ 9322 'port_override: ' + repr(self.port_override) + ' ' +\ 9323 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 9324 'tags: ' + repr(self.tags) + ' ' +\ 9325 '>' 9326 9327 def to_dict(self): 9328 return { 9329 'egress_filter': self.egress_filter, 9330 'healthy': self.healthy, 9331 'hostname': self.hostname, 9332 'id': self.id, 9333 'name': self.name, 9334 'port': self.port, 9335 'port_override': self.port_override, 9336 'secret_store_id': self.secret_store_id, 9337 'tags': self.tags, 9338 } 9339 9340 @classmethod 9341 def from_dict(cls, d): 9342 return cls( 9343 egress_filter=d.get('egress_filter'), 9344 healthy=d.get('healthy'), 9345 hostname=d.get('hostname'), 9346 id=d.get('id'), 9347 name=d.get('name'), 9348 port=d.get('port'), 9349 port_override=d.get('port_override'), 9350 secret_store_id=d.get('secret_store_id'), 9351 tags=d.get('tags'), 9352 )
#
RawTCP(
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
port=None,
port_override=None,
secret_store_id=None,
tags=None
)
View Source
9265 def __init__( 9266 self, 9267 egress_filter=None, 9268 healthy=None, 9269 hostname=None, 9270 id=None, 9271 name=None, 9272 port=None, 9273 port_override=None, 9274 secret_store_id=None, 9275 tags=None, 9276 ): 9277 self.egress_filter = egress_filter if egress_filter is not None else '' 9278 ''' 9279 A filter applied to the routing logic to pin datasource to nodes. 9280 ''' 9281 self.healthy = healthy if healthy is not None else False 9282 ''' 9283 True if the datasource is reachable and the credentials are valid. 9284 ''' 9285 self.hostname = hostname if hostname is not None else '' 9286 ''' 9287 9288 ''' 9289 self.id = id if id is not None else '' 9290 ''' 9291 Unique identifier of the Resource. 9292 ''' 9293 self.name = name if name is not None else '' 9294 ''' 9295 Unique human-readable name of the Resource. 9296 ''' 9297 self.port = port if port is not None else 0 9298 ''' 9299 9300 ''' 9301 self.port_override = port_override if port_override is not None else 0 9302 ''' 9303 9304 ''' 9305 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 9306 ''' 9307 ID of the secret store containing credentials for this resource, if any. 9308 ''' 9309 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 9310 ''' 9311 Tags is a map of key, value pairs. 9312 '''
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
port
#
port_override
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
View Source
9327 def to_dict(self): 9328 return { 9329 'egress_filter': self.egress_filter, 9330 'healthy': self.healthy, 9331 'hostname': self.hostname, 9332 'id': self.id, 9333 'name': self.name, 9334 'port': self.port, 9335 'port_override': self.port_override, 9336 'secret_store_id': self.secret_store_id, 9337 'tags': self.tags, 9338 }
View Source
9340 @classmethod 9341 def from_dict(cls, d): 9342 return cls( 9343 egress_filter=d.get('egress_filter'), 9344 healthy=d.get('healthy'), 9345 hostname=d.get('hostname'), 9346 id=d.get('id'), 9347 name=d.get('name'), 9348 port=d.get('port'), 9349 port_override=d.get('port_override'), 9350 secret_store_id=d.get('secret_store_id'), 9351 tags=d.get('tags'), 9352 )
View Source
9355class Redis: 9356 ''' 9357 9358 ''' 9359 __slots__ = [ 9360 'egress_filter', 9361 'healthy', 9362 'hostname', 9363 'id', 9364 'name', 9365 'password', 9366 'port', 9367 'port_override', 9368 'secret_store_id', 9369 'tags', 9370 ] 9371 9372 def __init__( 9373 self, 9374 egress_filter=None, 9375 healthy=None, 9376 hostname=None, 9377 id=None, 9378 name=None, 9379 password=None, 9380 port=None, 9381 port_override=None, 9382 secret_store_id=None, 9383 tags=None, 9384 ): 9385 self.egress_filter = egress_filter if egress_filter is not None else '' 9386 ''' 9387 A filter applied to the routing logic to pin datasource to nodes. 9388 ''' 9389 self.healthy = healthy if healthy is not None else False 9390 ''' 9391 True if the datasource is reachable and the credentials are valid. 9392 ''' 9393 self.hostname = hostname if hostname is not None else '' 9394 ''' 9395 9396 ''' 9397 self.id = id if id is not None else '' 9398 ''' 9399 Unique identifier of the Resource. 9400 ''' 9401 self.name = name if name is not None else '' 9402 ''' 9403 Unique human-readable name of the Resource. 9404 ''' 9405 self.password = password if password is not None else '' 9406 ''' 9407 9408 ''' 9409 self.port = port if port is not None else 0 9410 ''' 9411 9412 ''' 9413 self.port_override = port_override if port_override is not None else 0 9414 ''' 9415 9416 ''' 9417 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 9418 ''' 9419 ID of the secret store containing credentials for this resource, if any. 9420 ''' 9421 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 9422 ''' 9423 Tags is a map of key, value pairs. 9424 ''' 9425 9426 def __repr__(self): 9427 return '<sdm.Redis ' + \ 9428 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 9429 'healthy: ' + repr(self.healthy) + ' ' +\ 9430 'hostname: ' + repr(self.hostname) + ' ' +\ 9431 'id: ' + repr(self.id) + ' ' +\ 9432 'name: ' + repr(self.name) + ' ' +\ 9433 'password: ' + repr(self.password) + ' ' +\ 9434 'port: ' + repr(self.port) + ' ' +\ 9435 'port_override: ' + repr(self.port_override) + ' ' +\ 9436 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 9437 'tags: ' + repr(self.tags) + ' ' +\ 9438 '>' 9439 9440 def to_dict(self): 9441 return { 9442 'egress_filter': self.egress_filter, 9443 'healthy': self.healthy, 9444 'hostname': self.hostname, 9445 'id': self.id, 9446 'name': self.name, 9447 'password': self.password, 9448 'port': self.port, 9449 'port_override': self.port_override, 9450 'secret_store_id': self.secret_store_id, 9451 'tags': self.tags, 9452 } 9453 9454 @classmethod 9455 def from_dict(cls, d): 9456 return cls( 9457 egress_filter=d.get('egress_filter'), 9458 healthy=d.get('healthy'), 9459 hostname=d.get('hostname'), 9460 id=d.get('id'), 9461 name=d.get('name'), 9462 password=d.get('password'), 9463 port=d.get('port'), 9464 port_override=d.get('port_override'), 9465 secret_store_id=d.get('secret_store_id'), 9466 tags=d.get('tags'), 9467 )
#
Redis(
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
password=None,
port=None,
port_override=None,
secret_store_id=None,
tags=None
)
View Source
9372 def __init__( 9373 self, 9374 egress_filter=None, 9375 healthy=None, 9376 hostname=None, 9377 id=None, 9378 name=None, 9379 password=None, 9380 port=None, 9381 port_override=None, 9382 secret_store_id=None, 9383 tags=None, 9384 ): 9385 self.egress_filter = egress_filter if egress_filter is not None else '' 9386 ''' 9387 A filter applied to the routing logic to pin datasource to nodes. 9388 ''' 9389 self.healthy = healthy if healthy is not None else False 9390 ''' 9391 True if the datasource is reachable and the credentials are valid. 9392 ''' 9393 self.hostname = hostname if hostname is not None else '' 9394 ''' 9395 9396 ''' 9397 self.id = id if id is not None else '' 9398 ''' 9399 Unique identifier of the Resource. 9400 ''' 9401 self.name = name if name is not None else '' 9402 ''' 9403 Unique human-readable name of the Resource. 9404 ''' 9405 self.password = password if password is not None else '' 9406 ''' 9407 9408 ''' 9409 self.port = port if port is not None else 0 9410 ''' 9411 9412 ''' 9413 self.port_override = port_override if port_override is not None else 0 9414 ''' 9415 9416 ''' 9417 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 9418 ''' 9419 ID of the secret store containing credentials for this resource, if any. 9420 ''' 9421 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 9422 ''' 9423 Tags is a map of key, value pairs. 9424 '''
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
password
#
port
#
port_override
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
View Source
9440 def to_dict(self): 9441 return { 9442 'egress_filter': self.egress_filter, 9443 'healthy': self.healthy, 9444 'hostname': self.hostname, 9445 'id': self.id, 9446 'name': self.name, 9447 'password': self.password, 9448 'port': self.port, 9449 'port_override': self.port_override, 9450 'secret_store_id': self.secret_store_id, 9451 'tags': self.tags, 9452 }
View Source
9454 @classmethod 9455 def from_dict(cls, d): 9456 return cls( 9457 egress_filter=d.get('egress_filter'), 9458 healthy=d.get('healthy'), 9459 hostname=d.get('hostname'), 9460 id=d.get('id'), 9461 name=d.get('name'), 9462 password=d.get('password'), 9463 port=d.get('port'), 9464 port_override=d.get('port_override'), 9465 secret_store_id=d.get('secret_store_id'), 9466 tags=d.get('tags'), 9467 )
View Source
9470class Redshift: 9471 ''' 9472 9473 ''' 9474 __slots__ = [ 9475 'database', 9476 'egress_filter', 9477 'healthy', 9478 'hostname', 9479 'id', 9480 'name', 9481 'override_database', 9482 'password', 9483 'port', 9484 'port_override', 9485 'secret_store_id', 9486 'tags', 9487 'username', 9488 ] 9489 9490 def __init__( 9491 self, 9492 database=None, 9493 egress_filter=None, 9494 healthy=None, 9495 hostname=None, 9496 id=None, 9497 name=None, 9498 override_database=None, 9499 password=None, 9500 port=None, 9501 port_override=None, 9502 secret_store_id=None, 9503 tags=None, 9504 username=None, 9505 ): 9506 self.database = database if database is not None else '' 9507 ''' 9508 9509 ''' 9510 self.egress_filter = egress_filter if egress_filter is not None else '' 9511 ''' 9512 A filter applied to the routing logic to pin datasource to nodes. 9513 ''' 9514 self.healthy = healthy if healthy is not None else False 9515 ''' 9516 True if the datasource is reachable and the credentials are valid. 9517 ''' 9518 self.hostname = hostname if hostname is not None else '' 9519 ''' 9520 9521 ''' 9522 self.id = id if id is not None else '' 9523 ''' 9524 Unique identifier of the Resource. 9525 ''' 9526 self.name = name if name is not None else '' 9527 ''' 9528 Unique human-readable name of the Resource. 9529 ''' 9530 self.override_database = override_database if override_database is not None else False 9531 ''' 9532 9533 ''' 9534 self.password = password if password is not None else '' 9535 ''' 9536 9537 ''' 9538 self.port = port if port is not None else 0 9539 ''' 9540 9541 ''' 9542 self.port_override = port_override if port_override is not None else 0 9543 ''' 9544 9545 ''' 9546 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 9547 ''' 9548 ID of the secret store containing credentials for this resource, if any. 9549 ''' 9550 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 9551 ''' 9552 Tags is a map of key, value pairs. 9553 ''' 9554 self.username = username if username is not None else '' 9555 ''' 9556 9557 ''' 9558 9559 def __repr__(self): 9560 return '<sdm.Redshift ' + \ 9561 'database: ' + repr(self.database) + ' ' +\ 9562 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 9563 'healthy: ' + repr(self.healthy) + ' ' +\ 9564 'hostname: ' + repr(self.hostname) + ' ' +\ 9565 'id: ' + repr(self.id) + ' ' +\ 9566 'name: ' + repr(self.name) + ' ' +\ 9567 'override_database: ' + repr(self.override_database) + ' ' +\ 9568 'password: ' + repr(self.password) + ' ' +\ 9569 'port: ' + repr(self.port) + ' ' +\ 9570 'port_override: ' + repr(self.port_override) + ' ' +\ 9571 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 9572 'tags: ' + repr(self.tags) + ' ' +\ 9573 'username: ' + repr(self.username) + ' ' +\ 9574 '>' 9575 9576 def to_dict(self): 9577 return { 9578 'database': self.database, 9579 'egress_filter': self.egress_filter, 9580 'healthy': self.healthy, 9581 'hostname': self.hostname, 9582 'id': self.id, 9583 'name': self.name, 9584 'override_database': self.override_database, 9585 'password': self.password, 9586 'port': self.port, 9587 'port_override': self.port_override, 9588 'secret_store_id': self.secret_store_id, 9589 'tags': self.tags, 9590 'username': self.username, 9591 } 9592 9593 @classmethod 9594 def from_dict(cls, d): 9595 return cls( 9596 database=d.get('database'), 9597 egress_filter=d.get('egress_filter'), 9598 healthy=d.get('healthy'), 9599 hostname=d.get('hostname'), 9600 id=d.get('id'), 9601 name=d.get('name'), 9602 override_database=d.get('override_database'), 9603 password=d.get('password'), 9604 port=d.get('port'), 9605 port_override=d.get('port_override'), 9606 secret_store_id=d.get('secret_store_id'), 9607 tags=d.get('tags'), 9608 username=d.get('username'), 9609 )
#
Redshift(
database=None,
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
override_database=None,
password=None,
port=None,
port_override=None,
secret_store_id=None,
tags=None,
username=None
)
View Source
9490 def __init__( 9491 self, 9492 database=None, 9493 egress_filter=None, 9494 healthy=None, 9495 hostname=None, 9496 id=None, 9497 name=None, 9498 override_database=None, 9499 password=None, 9500 port=None, 9501 port_override=None, 9502 secret_store_id=None, 9503 tags=None, 9504 username=None, 9505 ): 9506 self.database = database if database is not None else '' 9507 ''' 9508 9509 ''' 9510 self.egress_filter = egress_filter if egress_filter is not None else '' 9511 ''' 9512 A filter applied to the routing logic to pin datasource to nodes. 9513 ''' 9514 self.healthy = healthy if healthy is not None else False 9515 ''' 9516 True if the datasource is reachable and the credentials are valid. 9517 ''' 9518 self.hostname = hostname if hostname is not None else '' 9519 ''' 9520 9521 ''' 9522 self.id = id if id is not None else '' 9523 ''' 9524 Unique identifier of the Resource. 9525 ''' 9526 self.name = name if name is not None else '' 9527 ''' 9528 Unique human-readable name of the Resource. 9529 ''' 9530 self.override_database = override_database if override_database is not None else False 9531 ''' 9532 9533 ''' 9534 self.password = password if password is not None else '' 9535 ''' 9536 9537 ''' 9538 self.port = port if port is not None else 0 9539 ''' 9540 9541 ''' 9542 self.port_override = port_override if port_override is not None else 0 9543 ''' 9544 9545 ''' 9546 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 9547 ''' 9548 ID of the secret store containing credentials for this resource, if any. 9549 ''' 9550 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 9551 ''' 9552 Tags is a map of key, value pairs. 9553 ''' 9554 self.username = username if username is not None else '' 9555 ''' 9556 9557 '''
#
database
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
override_database
#
password
#
port
#
port_override
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
username
View Source
9576 def to_dict(self): 9577 return { 9578 'database': self.database, 9579 'egress_filter': self.egress_filter, 9580 'healthy': self.healthy, 9581 'hostname': self.hostname, 9582 'id': self.id, 9583 'name': self.name, 9584 'override_database': self.override_database, 9585 'password': self.password, 9586 'port': self.port, 9587 'port_override': self.port_override, 9588 'secret_store_id': self.secret_store_id, 9589 'tags': self.tags, 9590 'username': self.username, 9591 }
View Source
9593 @classmethod 9594 def from_dict(cls, d): 9595 return cls( 9596 database=d.get('database'), 9597 egress_filter=d.get('egress_filter'), 9598 healthy=d.get('healthy'), 9599 hostname=d.get('hostname'), 9600 id=d.get('id'), 9601 name=d.get('name'), 9602 override_database=d.get('override_database'), 9603 password=d.get('password'), 9604 port=d.get('port'), 9605 port_override=d.get('port_override'), 9606 secret_store_id=d.get('secret_store_id'), 9607 tags=d.get('tags'), 9608 username=d.get('username'), 9609 )
View Source
9612class Relay: 9613 ''' 9614 Relay represents a StrongDM CLI installation running in relay mode. 9615 ''' 9616 __slots__ = [ 9617 'gateway_filter', 9618 'id', 9619 'name', 9620 'state', 9621 'tags', 9622 ] 9623 9624 def __init__( 9625 self, 9626 gateway_filter=None, 9627 id=None, 9628 name=None, 9629 state=None, 9630 tags=None, 9631 ): 9632 self.gateway_filter = gateway_filter if gateway_filter is not None else '' 9633 ''' 9634 GatewayFilter can be used to restrict the peering between relays and 9635 gateways. 9636 ''' 9637 self.id = id if id is not None else '' 9638 ''' 9639 Unique identifier of the Relay. 9640 ''' 9641 self.name = name if name is not None else '' 9642 ''' 9643 Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create. 9644 ''' 9645 self.state = state if state is not None else '' 9646 ''' 9647 The current state of the relay. One of: "new", "verifying_restart", 9648 "awaiting_restart", "restarting", "started", "stopped", "dead", 9649 "unknown". 9650 ''' 9651 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 9652 ''' 9653 Tags is a map of key, value pairs. 9654 ''' 9655 9656 def __repr__(self): 9657 return '<sdm.Relay ' + \ 9658 'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\ 9659 'id: ' + repr(self.id) + ' ' +\ 9660 'name: ' + repr(self.name) + ' ' +\ 9661 'state: ' + repr(self.state) + ' ' +\ 9662 'tags: ' + repr(self.tags) + ' ' +\ 9663 '>' 9664 9665 def to_dict(self): 9666 return { 9667 'gateway_filter': self.gateway_filter, 9668 'id': self.id, 9669 'name': self.name, 9670 'state': self.state, 9671 'tags': self.tags, 9672 } 9673 9674 @classmethod 9675 def from_dict(cls, d): 9676 return cls( 9677 gateway_filter=d.get('gateway_filter'), 9678 id=d.get('id'), 9679 name=d.get('name'), 9680 state=d.get('state'), 9681 tags=d.get('tags'), 9682 )
Relay represents a StrongDM CLI installation running in relay mode.
View Source
9624 def __init__( 9625 self, 9626 gateway_filter=None, 9627 id=None, 9628 name=None, 9629 state=None, 9630 tags=None, 9631 ): 9632 self.gateway_filter = gateway_filter if gateway_filter is not None else '' 9633 ''' 9634 GatewayFilter can be used to restrict the peering between relays and 9635 gateways. 9636 ''' 9637 self.id = id if id is not None else '' 9638 ''' 9639 Unique identifier of the Relay. 9640 ''' 9641 self.name = name if name is not None else '' 9642 ''' 9643 Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create. 9644 ''' 9645 self.state = state if state is not None else '' 9646 ''' 9647 The current state of the relay. One of: "new", "verifying_restart", 9648 "awaiting_restart", "restarting", "started", "stopped", "dead", 9649 "unknown". 9650 ''' 9651 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 9652 ''' 9653 Tags is a map of key, value pairs. 9654 '''
#
gateway_filter
GatewayFilter can be used to restrict the peering between relays and gateways.
#
id
Unique identifier of the Relay.
#
name
Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
#
state
The current state of the relay. One of: "new", "verifying_restart", "awaiting_restart", "restarting", "started", "stopped", "dead", "unknown".
View Source
9685class ResourceCreateResponse: 9686 ''' 9687 ResourceCreateResponse reports how the Resources were created in the system. 9688 ''' 9689 __slots__ = [ 9690 'meta', 9691 'rate_limit', 9692 'resource', 9693 ] 9694 9695 def __init__( 9696 self, 9697 meta=None, 9698 rate_limit=None, 9699 resource=None, 9700 ): 9701 self.meta = meta if meta is not None else None 9702 ''' 9703 Reserved for future use. 9704 ''' 9705 self.rate_limit = rate_limit if rate_limit is not None else None 9706 ''' 9707 Rate limit information. 9708 ''' 9709 self.resource = resource if resource is not None else None 9710 ''' 9711 The created Resource. 9712 ''' 9713 9714 def __repr__(self): 9715 return '<sdm.ResourceCreateResponse ' + \ 9716 'meta: ' + repr(self.meta) + ' ' +\ 9717 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 9718 'resource: ' + repr(self.resource) + ' ' +\ 9719 '>' 9720 9721 def to_dict(self): 9722 return { 9723 'meta': self.meta, 9724 'rate_limit': self.rate_limit, 9725 'resource': self.resource, 9726 } 9727 9728 @classmethod 9729 def from_dict(cls, d): 9730 return cls( 9731 meta=d.get('meta'), 9732 rate_limit=d.get('rate_limit'), 9733 resource=d.get('resource'), 9734 )
ResourceCreateResponse reports how the Resources were created in the system.
View Source
9695 def __init__( 9696 self, 9697 meta=None, 9698 rate_limit=None, 9699 resource=None, 9700 ): 9701 self.meta = meta if meta is not None else None 9702 ''' 9703 Reserved for future use. 9704 ''' 9705 self.rate_limit = rate_limit if rate_limit is not None else None 9706 ''' 9707 Rate limit information. 9708 ''' 9709 self.resource = resource if resource is not None else None 9710 ''' 9711 The created Resource. 9712 '''
#
meta
Reserved for future use.
#
rate_limit
Rate limit information.
#
resource
The created Resource.
View Source
9737class ResourceDeleteResponse: 9738 ''' 9739 ResourceDeleteResponse returns information about a Resource that was deleted. 9740 ''' 9741 __slots__ = [ 9742 'meta', 9743 'rate_limit', 9744 ] 9745 9746 def __init__( 9747 self, 9748 meta=None, 9749 rate_limit=None, 9750 ): 9751 self.meta = meta if meta is not None else None 9752 ''' 9753 Reserved for future use. 9754 ''' 9755 self.rate_limit = rate_limit if rate_limit is not None else None 9756 ''' 9757 Rate limit information. 9758 ''' 9759 9760 def __repr__(self): 9761 return '<sdm.ResourceDeleteResponse ' + \ 9762 'meta: ' + repr(self.meta) + ' ' +\ 9763 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 9764 '>' 9765 9766 def to_dict(self): 9767 return { 9768 'meta': self.meta, 9769 'rate_limit': self.rate_limit, 9770 } 9771 9772 @classmethod 9773 def from_dict(cls, d): 9774 return cls( 9775 meta=d.get('meta'), 9776 rate_limit=d.get('rate_limit'), 9777 )
ResourceDeleteResponse returns information about a Resource that was deleted.
View Source
#
meta
Reserved for future use.
#
rate_limit
Rate limit information.
View Source
9780class ResourceGetResponse: 9781 ''' 9782 ResourceGetResponse returns a requested Resource. 9783 ''' 9784 __slots__ = [ 9785 'meta', 9786 'rate_limit', 9787 'resource', 9788 ] 9789 9790 def __init__( 9791 self, 9792 meta=None, 9793 rate_limit=None, 9794 resource=None, 9795 ): 9796 self.meta = meta if meta is not None else None 9797 ''' 9798 Reserved for future use. 9799 ''' 9800 self.rate_limit = rate_limit if rate_limit is not None else None 9801 ''' 9802 Rate limit information. 9803 ''' 9804 self.resource = resource if resource is not None else None 9805 ''' 9806 The requested Resource. 9807 ''' 9808 9809 def __repr__(self): 9810 return '<sdm.ResourceGetResponse ' + \ 9811 'meta: ' + repr(self.meta) + ' ' +\ 9812 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 9813 'resource: ' + repr(self.resource) + ' ' +\ 9814 '>' 9815 9816 def to_dict(self): 9817 return { 9818 'meta': self.meta, 9819 'rate_limit': self.rate_limit, 9820 'resource': self.resource, 9821 } 9822 9823 @classmethod 9824 def from_dict(cls, d): 9825 return cls( 9826 meta=d.get('meta'), 9827 rate_limit=d.get('rate_limit'), 9828 resource=d.get('resource'), 9829 )
ResourceGetResponse returns a requested Resource.
View Source
9790 def __init__( 9791 self, 9792 meta=None, 9793 rate_limit=None, 9794 resource=None, 9795 ): 9796 self.meta = meta if meta is not None else None 9797 ''' 9798 Reserved for future use. 9799 ''' 9800 self.rate_limit = rate_limit if rate_limit is not None else None 9801 ''' 9802 Rate limit information. 9803 ''' 9804 self.resource = resource if resource is not None else None 9805 ''' 9806 The requested Resource. 9807 '''
#
meta
Reserved for future use.
#
rate_limit
Rate limit information.
#
resource
The requested Resource.
View Source
9832class ResourceUpdateResponse: 9833 ''' 9834 ResourceUpdateResponse returns the fields of a Resource after it has been updated by 9835 a ResourceUpdateRequest. 9836 ''' 9837 __slots__ = [ 9838 'meta', 9839 'rate_limit', 9840 'resource', 9841 ] 9842 9843 def __init__( 9844 self, 9845 meta=None, 9846 rate_limit=None, 9847 resource=None, 9848 ): 9849 self.meta = meta if meta is not None else None 9850 ''' 9851 Reserved for future use. 9852 ''' 9853 self.rate_limit = rate_limit if rate_limit is not None else None 9854 ''' 9855 Rate limit information. 9856 ''' 9857 self.resource = resource if resource is not None else None 9858 ''' 9859 The updated Resource. 9860 ''' 9861 9862 def __repr__(self): 9863 return '<sdm.ResourceUpdateResponse ' + \ 9864 'meta: ' + repr(self.meta) + ' ' +\ 9865 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 9866 'resource: ' + repr(self.resource) + ' ' +\ 9867 '>' 9868 9869 def to_dict(self): 9870 return { 9871 'meta': self.meta, 9872 'rate_limit': self.rate_limit, 9873 'resource': self.resource, 9874 } 9875 9876 @classmethod 9877 def from_dict(cls, d): 9878 return cls( 9879 meta=d.get('meta'), 9880 rate_limit=d.get('rate_limit'), 9881 resource=d.get('resource'), 9882 )
ResourceUpdateResponse returns the fields of a Resource after it has been updated by a ResourceUpdateRequest.
View Source
9843 def __init__( 9844 self, 9845 meta=None, 9846 rate_limit=None, 9847 resource=None, 9848 ): 9849 self.meta = meta if meta is not None else None 9850 ''' 9851 Reserved for future use. 9852 ''' 9853 self.rate_limit = rate_limit if rate_limit is not None else None 9854 ''' 9855 Rate limit information. 9856 ''' 9857 self.resource = resource if resource is not None else None 9858 ''' 9859 The updated Resource. 9860 '''
#
meta
Reserved for future use.
#
rate_limit
Rate limit information.
#
resource
The updated Resource.
View Source
9885class Role: 9886 ''' 9887 A Role has a list of access rules which determine which Resources the members 9888 of the Role have access to. An Account can be a member of multiple Roles via 9889 AccountAttachments. 9890 ''' 9891 __slots__ = [ 9892 'access_rules', 9893 'composite', 9894 'id', 9895 'name', 9896 'tags', 9897 ] 9898 9899 def __init__( 9900 self, 9901 access_rules=None, 9902 composite=None, 9903 id=None, 9904 name=None, 9905 tags=None, 9906 ): 9907 self.access_rules = access_rules if access_rules is not None else _porcelain_zero_value_access_rules( 9908 ) 9909 ''' 9910 AccessRules is a list of access rules defining the resources this Role has access to. 9911 ''' 9912 self.composite = composite if composite is not None else False 9913 ''' 9914 Composite is true if the Role is a composite role. 9915 9916 Deprecated: composite roles are deprecated, use multi-role via 9917 AccountAttachments instead. 9918 ''' 9919 self.id = id if id is not None else '' 9920 ''' 9921 Unique identifier of the Role. 9922 ''' 9923 self.name = name if name is not None else '' 9924 ''' 9925 Unique human-readable name of the Role. 9926 ''' 9927 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 9928 ''' 9929 Tags is a map of key, value pairs. 9930 ''' 9931 9932 def __repr__(self): 9933 return '<sdm.Role ' + \ 9934 'access_rules: ' + repr(self.access_rules) + ' ' +\ 9935 'composite: ' + repr(self.composite) + ' ' +\ 9936 'id: ' + repr(self.id) + ' ' +\ 9937 'name: ' + repr(self.name) + ' ' +\ 9938 'tags: ' + repr(self.tags) + ' ' +\ 9939 '>' 9940 9941 def to_dict(self): 9942 return { 9943 'access_rules': self.access_rules, 9944 'composite': self.composite, 9945 'id': self.id, 9946 'name': self.name, 9947 'tags': self.tags, 9948 } 9949 9950 @classmethod 9951 def from_dict(cls, d): 9952 return cls( 9953 access_rules=d.get('access_rules'), 9954 composite=d.get('composite'), 9955 id=d.get('id'), 9956 name=d.get('name'), 9957 tags=d.get('tags'), 9958 )
A Role has a list of access rules which determine which Resources the members of the Role have access to. An Account can be a member of multiple Roles via AccountAttachments.
View Source
9899 def __init__( 9900 self, 9901 access_rules=None, 9902 composite=None, 9903 id=None, 9904 name=None, 9905 tags=None, 9906 ): 9907 self.access_rules = access_rules if access_rules is not None else _porcelain_zero_value_access_rules( 9908 ) 9909 ''' 9910 AccessRules is a list of access rules defining the resources this Role has access to. 9911 ''' 9912 self.composite = composite if composite is not None else False 9913 ''' 9914 Composite is true if the Role is a composite role. 9915 9916 Deprecated: composite roles are deprecated, use multi-role via 9917 AccountAttachments instead. 9918 ''' 9919 self.id = id if id is not None else '' 9920 ''' 9921 Unique identifier of the Role. 9922 ''' 9923 self.name = name if name is not None else '' 9924 ''' 9925 Unique human-readable name of the Role. 9926 ''' 9927 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 9928 ''' 9929 Tags is a map of key, value pairs. 9930 '''
#
access_rules
AccessRules is a list of access rules defining the resources this Role has access to.
#
composite
Composite is true if the Role is a composite role.
Deprecated: composite roles are deprecated, use multi-role via AccountAttachments instead.
#
id
Unique identifier of the Role.
#
name
Unique human-readable name of the Role.
View Source
9961class RoleAttachment: 9962 ''' 9963 A RoleAttachment assigns a role to a composite role. 9964 9965 Deprecated: use multi-role via AccountAttachments instead. 9966 ''' 9967 __slots__ = [ 9968 'attached_role_id', 9969 'composite_role_id', 9970 'id', 9971 ] 9972 9973 def __init__( 9974 self, 9975 attached_role_id=None, 9976 composite_role_id=None, 9977 id=None, 9978 ): 9979 self.attached_role_id = attached_role_id if attached_role_id is not None else '' 9980 ''' 9981 The id of the attached role of this RoleAttachment. 9982 ''' 9983 self.composite_role_id = composite_role_id if composite_role_id is not None else '' 9984 ''' 9985 The id of the composite role of this RoleAttachment. 9986 ''' 9987 self.id = id if id is not None else '' 9988 ''' 9989 Unique identifier of the RoleAttachment. 9990 ''' 9991 9992 def __repr__(self): 9993 return '<sdm.RoleAttachment ' + \ 9994 'attached_role_id: ' + repr(self.attached_role_id) + ' ' +\ 9995 'composite_role_id: ' + repr(self.composite_role_id) + ' ' +\ 9996 'id: ' + repr(self.id) + ' ' +\ 9997 '>' 9998 9999 def to_dict(self): 10000 return { 10001 'attached_role_id': self.attached_role_id, 10002 'composite_role_id': self.composite_role_id, 10003 'id': self.id, 10004 } 10005 10006 @classmethod 10007 def from_dict(cls, d): 10008 return cls( 10009 attached_role_id=d.get('attached_role_id'), 10010 composite_role_id=d.get('composite_role_id'), 10011 id=d.get('id'), 10012 )
A RoleAttachment assigns a role to a composite role.
Deprecated: use multi-role via AccountAttachments instead.
View Source
9973 def __init__( 9974 self, 9975 attached_role_id=None, 9976 composite_role_id=None, 9977 id=None, 9978 ): 9979 self.attached_role_id = attached_role_id if attached_role_id is not None else '' 9980 ''' 9981 The id of the attached role of this RoleAttachment. 9982 ''' 9983 self.composite_role_id = composite_role_id if composite_role_id is not None else '' 9984 ''' 9985 The id of the composite role of this RoleAttachment. 9986 ''' 9987 self.id = id if id is not None else '' 9988 ''' 9989 Unique identifier of the RoleAttachment. 9990 '''
#
attached_role_id
The id of the attached role of this RoleAttachment.
#
composite_role_id
The id of the composite role of this RoleAttachment.
#
id
Unique identifier of the RoleAttachment.
View Source
10015class RoleAttachmentCreateResponse: 10016 ''' 10017 RoleAttachmentCreateResponse reports how the RoleAttachments were created in the system. 10018 10019 Deprecated: use multi-role via AccountAttachments instead. 10020 ''' 10021 __slots__ = [ 10022 'meta', 10023 'rate_limit', 10024 'role_attachment', 10025 ] 10026 10027 def __init__( 10028 self, 10029 meta=None, 10030 rate_limit=None, 10031 role_attachment=None, 10032 ): 10033 self.meta = meta if meta is not None else None 10034 ''' 10035 Reserved for future use. 10036 ''' 10037 self.rate_limit = rate_limit if rate_limit is not None else None 10038 ''' 10039 Rate limit information. 10040 ''' 10041 self.role_attachment = role_attachment if role_attachment is not None else None 10042 ''' 10043 The created RoleAttachment. 10044 ''' 10045 10046 def __repr__(self): 10047 return '<sdm.RoleAttachmentCreateResponse ' + \ 10048 'meta: ' + repr(self.meta) + ' ' +\ 10049 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 10050 'role_attachment: ' + repr(self.role_attachment) + ' ' +\ 10051 '>' 10052 10053 def to_dict(self): 10054 return { 10055 'meta': self.meta, 10056 'rate_limit': self.rate_limit, 10057 'role_attachment': self.role_attachment, 10058 } 10059 10060 @classmethod 10061 def from_dict(cls, d): 10062 return cls( 10063 meta=d.get('meta'), 10064 rate_limit=d.get('rate_limit'), 10065 role_attachment=d.get('role_attachment'), 10066 )
RoleAttachmentCreateResponse reports how the RoleAttachments were created in the system.
Deprecated: use multi-role via AccountAttachments instead.
View Source
10027 def __init__( 10028 self, 10029 meta=None, 10030 rate_limit=None, 10031 role_attachment=None, 10032 ): 10033 self.meta = meta if meta is not None else None 10034 ''' 10035 Reserved for future use. 10036 ''' 10037 self.rate_limit = rate_limit if rate_limit is not None else None 10038 ''' 10039 Rate limit information. 10040 ''' 10041 self.role_attachment = role_attachment if role_attachment is not None else None 10042 ''' 10043 The created RoleAttachment. 10044 '''
#
meta
Reserved for future use.
#
rate_limit
Rate limit information.
#
role_attachment
The created RoleAttachment.
View Source
10069class RoleAttachmentDeleteResponse: 10070 ''' 10071 RoleAttachmentDeleteResponse returns information about a RoleAttachment that was deleted. 10072 10073 Deprecated: use multi-role via AccountAttachments instead. 10074 ''' 10075 __slots__ = [ 10076 'meta', 10077 'rate_limit', 10078 ] 10079 10080 def __init__( 10081 self, 10082 meta=None, 10083 rate_limit=None, 10084 ): 10085 self.meta = meta if meta is not None else None 10086 ''' 10087 Reserved for future use. 10088 ''' 10089 self.rate_limit = rate_limit if rate_limit is not None else None 10090 ''' 10091 Rate limit information. 10092 ''' 10093 10094 def __repr__(self): 10095 return '<sdm.RoleAttachmentDeleteResponse ' + \ 10096 'meta: ' + repr(self.meta) + ' ' +\ 10097 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 10098 '>' 10099 10100 def to_dict(self): 10101 return { 10102 'meta': self.meta, 10103 'rate_limit': self.rate_limit, 10104 } 10105 10106 @classmethod 10107 def from_dict(cls, d): 10108 return cls( 10109 meta=d.get('meta'), 10110 rate_limit=d.get('rate_limit'), 10111 )
RoleAttachmentDeleteResponse returns information about a RoleAttachment that was deleted.
Deprecated: use multi-role via AccountAttachments instead.
View Source
10080 def __init__( 10081 self, 10082 meta=None, 10083 rate_limit=None, 10084 ): 10085 self.meta = meta if meta is not None else None 10086 ''' 10087 Reserved for future use. 10088 ''' 10089 self.rate_limit = rate_limit if rate_limit is not None else None 10090 ''' 10091 Rate limit information. 10092 '''
#
meta
Reserved for future use.
#
rate_limit
Rate limit information.
View Source
10114class RoleAttachmentGetResponse: 10115 ''' 10116 RoleAttachmentGetResponse returns a requested RoleAttachment. 10117 10118 Deprecated: use multi-role via AccountAttachments instead. 10119 ''' 10120 __slots__ = [ 10121 'meta', 10122 'rate_limit', 10123 'role_attachment', 10124 ] 10125 10126 def __init__( 10127 self, 10128 meta=None, 10129 rate_limit=None, 10130 role_attachment=None, 10131 ): 10132 self.meta = meta if meta is not None else None 10133 ''' 10134 Reserved for future use. 10135 ''' 10136 self.rate_limit = rate_limit if rate_limit is not None else None 10137 ''' 10138 Rate limit information. 10139 ''' 10140 self.role_attachment = role_attachment if role_attachment is not None else None 10141 ''' 10142 The requested RoleAttachment. 10143 ''' 10144 10145 def __repr__(self): 10146 return '<sdm.RoleAttachmentGetResponse ' + \ 10147 'meta: ' + repr(self.meta) + ' ' +\ 10148 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 10149 'role_attachment: ' + repr(self.role_attachment) + ' ' +\ 10150 '>' 10151 10152 def to_dict(self): 10153 return { 10154 'meta': self.meta, 10155 'rate_limit': self.rate_limit, 10156 'role_attachment': self.role_attachment, 10157 } 10158 10159 @classmethod 10160 def from_dict(cls, d): 10161 return cls( 10162 meta=d.get('meta'), 10163 rate_limit=d.get('rate_limit'), 10164 role_attachment=d.get('role_attachment'), 10165 )
RoleAttachmentGetResponse returns a requested RoleAttachment.
Deprecated: use multi-role via AccountAttachments instead.
View Source
10126 def __init__( 10127 self, 10128 meta=None, 10129 rate_limit=None, 10130 role_attachment=None, 10131 ): 10132 self.meta = meta if meta is not None else None 10133 ''' 10134 Reserved for future use. 10135 ''' 10136 self.rate_limit = rate_limit if rate_limit is not None else None 10137 ''' 10138 Rate limit information. 10139 ''' 10140 self.role_attachment = role_attachment if role_attachment is not None else None 10141 ''' 10142 The requested RoleAttachment. 10143 '''
#
meta
Reserved for future use.
#
rate_limit
Rate limit information.
#
role_attachment
The requested RoleAttachment.
View Source
10168class RoleCreateResponse: 10169 ''' 10170 RoleCreateResponse reports how the Roles were created in the system. It can 10171 communicate partial successes or failures. 10172 ''' 10173 __slots__ = [ 10174 'meta', 10175 'rate_limit', 10176 'role', 10177 ] 10178 10179 def __init__( 10180 self, 10181 meta=None, 10182 rate_limit=None, 10183 role=None, 10184 ): 10185 self.meta = meta if meta is not None else None 10186 ''' 10187 Reserved for future use. 10188 ''' 10189 self.rate_limit = rate_limit if rate_limit is not None else None 10190 ''' 10191 Rate limit information. 10192 ''' 10193 self.role = role if role is not None else None 10194 ''' 10195 The created Role. 10196 ''' 10197 10198 def __repr__(self): 10199 return '<sdm.RoleCreateResponse ' + \ 10200 'meta: ' + repr(self.meta) + ' ' +\ 10201 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 10202 'role: ' + repr(self.role) + ' ' +\ 10203 '>' 10204 10205 def to_dict(self): 10206 return { 10207 'meta': self.meta, 10208 'rate_limit': self.rate_limit, 10209 'role': self.role, 10210 } 10211 10212 @classmethod 10213 def from_dict(cls, d): 10214 return cls( 10215 meta=d.get('meta'), 10216 rate_limit=d.get('rate_limit'), 10217 role=d.get('role'), 10218 )
RoleCreateResponse reports how the Roles were created in the system. It can communicate partial successes or failures.
View Source
10179 def __init__( 10180 self, 10181 meta=None, 10182 rate_limit=None, 10183 role=None, 10184 ): 10185 self.meta = meta if meta is not None else None 10186 ''' 10187 Reserved for future use. 10188 ''' 10189 self.rate_limit = rate_limit if rate_limit is not None else None 10190 ''' 10191 Rate limit information. 10192 ''' 10193 self.role = role if role is not None else None 10194 ''' 10195 The created Role. 10196 '''
#
meta
Reserved for future use.
#
rate_limit
Rate limit information.
#
role
The created Role.
View Source
10221class RoleDeleteResponse: 10222 ''' 10223 RoleDeleteResponse returns information about a Role that was deleted. 10224 ''' 10225 __slots__ = [ 10226 'meta', 10227 'rate_limit', 10228 ] 10229 10230 def __init__( 10231 self, 10232 meta=None, 10233 rate_limit=None, 10234 ): 10235 self.meta = meta if meta is not None else None 10236 ''' 10237 Reserved for future use. 10238 ''' 10239 self.rate_limit = rate_limit if rate_limit is not None else None 10240 ''' 10241 Rate limit information. 10242 ''' 10243 10244 def __repr__(self): 10245 return '<sdm.RoleDeleteResponse ' + \ 10246 'meta: ' + repr(self.meta) + ' ' +\ 10247 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 10248 '>' 10249 10250 def to_dict(self): 10251 return { 10252 'meta': self.meta, 10253 'rate_limit': self.rate_limit, 10254 } 10255 10256 @classmethod 10257 def from_dict(cls, d): 10258 return cls( 10259 meta=d.get('meta'), 10260 rate_limit=d.get('rate_limit'), 10261 )
RoleDeleteResponse returns information about a Role that was deleted.
View Source
10230 def __init__( 10231 self, 10232 meta=None, 10233 rate_limit=None, 10234 ): 10235 self.meta = meta if meta is not None else None 10236 ''' 10237 Reserved for future use. 10238 ''' 10239 self.rate_limit = rate_limit if rate_limit is not None else None 10240 ''' 10241 Rate limit information. 10242 '''
#
meta
Reserved for future use.
#
rate_limit
Rate limit information.
View Source
10264class RoleGetResponse: 10265 ''' 10266 RoleGetResponse returns a requested Role. 10267 ''' 10268 __slots__ = [ 10269 'meta', 10270 'rate_limit', 10271 'role', 10272 ] 10273 10274 def __init__( 10275 self, 10276 meta=None, 10277 rate_limit=None, 10278 role=None, 10279 ): 10280 self.meta = meta if meta is not None else None 10281 ''' 10282 Reserved for future use. 10283 ''' 10284 self.rate_limit = rate_limit if rate_limit is not None else None 10285 ''' 10286 Rate limit information. 10287 ''' 10288 self.role = role if role is not None else None 10289 ''' 10290 The requested Role. 10291 ''' 10292 10293 def __repr__(self): 10294 return '<sdm.RoleGetResponse ' + \ 10295 'meta: ' + repr(self.meta) + ' ' +\ 10296 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 10297 'role: ' + repr(self.role) + ' ' +\ 10298 '>' 10299 10300 def to_dict(self): 10301 return { 10302 'meta': self.meta, 10303 'rate_limit': self.rate_limit, 10304 'role': self.role, 10305 } 10306 10307 @classmethod 10308 def from_dict(cls, d): 10309 return cls( 10310 meta=d.get('meta'), 10311 rate_limit=d.get('rate_limit'), 10312 role=d.get('role'), 10313 )
RoleGetResponse returns a requested Role.
View Source
10274 def __init__( 10275 self, 10276 meta=None, 10277 rate_limit=None, 10278 role=None, 10279 ): 10280 self.meta = meta if meta is not None else None 10281 ''' 10282 Reserved for future use. 10283 ''' 10284 self.rate_limit = rate_limit if rate_limit is not None else None 10285 ''' 10286 Rate limit information. 10287 ''' 10288 self.role = role if role is not None else None 10289 ''' 10290 The requested Role. 10291 '''
#
meta
Reserved for future use.
#
rate_limit
Rate limit information.
#
role
The requested Role.
View Source
10316class RoleGrant: 10317 ''' 10318 A RoleGrant connects a resource to a role, granting members of the role access to that resource. 10319 10320 Deprecated: use Role access rules instead. 10321 ''' 10322 __slots__ = [ 10323 'id', 10324 'resource_id', 10325 'role_id', 10326 ] 10327 10328 def __init__( 10329 self, 10330 id=None, 10331 resource_id=None, 10332 role_id=None, 10333 ): 10334 self.id = id if id is not None else '' 10335 ''' 10336 Unique identifier of the RoleGrant. 10337 ''' 10338 self.resource_id = resource_id if resource_id is not None else '' 10339 ''' 10340 The id of the resource of this RoleGrant. 10341 ''' 10342 self.role_id = role_id if role_id is not None else '' 10343 ''' 10344 The id of the attached role of this RoleGrant. 10345 ''' 10346 10347 def __repr__(self): 10348 return '<sdm.RoleGrant ' + \ 10349 'id: ' + repr(self.id) + ' ' +\ 10350 'resource_id: ' + repr(self.resource_id) + ' ' +\ 10351 'role_id: ' + repr(self.role_id) + ' ' +\ 10352 '>' 10353 10354 def to_dict(self): 10355 return { 10356 'id': self.id, 10357 'resource_id': self.resource_id, 10358 'role_id': self.role_id, 10359 } 10360 10361 @classmethod 10362 def from_dict(cls, d): 10363 return cls( 10364 id=d.get('id'), 10365 resource_id=d.get('resource_id'), 10366 role_id=d.get('role_id'), 10367 )
A RoleGrant connects a resource to a role, granting members of the role access to that resource.
Deprecated: use Role access rules instead.
View Source
10328 def __init__( 10329 self, 10330 id=None, 10331 resource_id=None, 10332 role_id=None, 10333 ): 10334 self.id = id if id is not None else '' 10335 ''' 10336 Unique identifier of the RoleGrant. 10337 ''' 10338 self.resource_id = resource_id if resource_id is not None else '' 10339 ''' 10340 The id of the resource of this RoleGrant. 10341 ''' 10342 self.role_id = role_id if role_id is not None else '' 10343 ''' 10344 The id of the attached role of this RoleGrant. 10345 '''
#
id
Unique identifier of the RoleGrant.
#
resource_id
The id of the resource of this RoleGrant.
#
role_id
The id of the attached role of this RoleGrant.
View Source
10370class RoleGrantCreateResponse: 10371 ''' 10372 RoleGrantCreateResponse reports how the RoleGrants were created in the system. 10373 10374 Deprecated: use Role access rules instead. 10375 ''' 10376 __slots__ = [ 10377 'meta', 10378 'rate_limit', 10379 'role_grant', 10380 ] 10381 10382 def __init__( 10383 self, 10384 meta=None, 10385 rate_limit=None, 10386 role_grant=None, 10387 ): 10388 self.meta = meta if meta is not None else None 10389 ''' 10390 Reserved for future use. 10391 ''' 10392 self.rate_limit = rate_limit if rate_limit is not None else None 10393 ''' 10394 Rate limit information. 10395 ''' 10396 self.role_grant = role_grant if role_grant is not None else None 10397 ''' 10398 The created RoleGrant. 10399 ''' 10400 10401 def __repr__(self): 10402 return '<sdm.RoleGrantCreateResponse ' + \ 10403 'meta: ' + repr(self.meta) + ' ' +\ 10404 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 10405 'role_grant: ' + repr(self.role_grant) + ' ' +\ 10406 '>' 10407 10408 def to_dict(self): 10409 return { 10410 'meta': self.meta, 10411 'rate_limit': self.rate_limit, 10412 'role_grant': self.role_grant, 10413 } 10414 10415 @classmethod 10416 def from_dict(cls, d): 10417 return cls( 10418 meta=d.get('meta'), 10419 rate_limit=d.get('rate_limit'), 10420 role_grant=d.get('role_grant'), 10421 )
RoleGrantCreateResponse reports how the RoleGrants were created in the system.
Deprecated: use Role access rules instead.
View Source
10382 def __init__( 10383 self, 10384 meta=None, 10385 rate_limit=None, 10386 role_grant=None, 10387 ): 10388 self.meta = meta if meta is not None else None 10389 ''' 10390 Reserved for future use. 10391 ''' 10392 self.rate_limit = rate_limit if rate_limit is not None else None 10393 ''' 10394 Rate limit information. 10395 ''' 10396 self.role_grant = role_grant if role_grant is not None else None 10397 ''' 10398 The created RoleGrant. 10399 '''
#
meta
Reserved for future use.
#
rate_limit
Rate limit information.
#
role_grant
The created RoleGrant.
View Source
10424class RoleGrantDeleteResponse: 10425 ''' 10426 RoleGrantDeleteResponse returns information about a RoleGrant that was deleted. 10427 10428 Deprecated: use Role access rules instead. 10429 ''' 10430 __slots__ = [ 10431 'meta', 10432 'rate_limit', 10433 ] 10434 10435 def __init__( 10436 self, 10437 meta=None, 10438 rate_limit=None, 10439 ): 10440 self.meta = meta if meta is not None else None 10441 ''' 10442 Reserved for future use. 10443 ''' 10444 self.rate_limit = rate_limit if rate_limit is not None else None 10445 ''' 10446 Rate limit information. 10447 ''' 10448 10449 def __repr__(self): 10450 return '<sdm.RoleGrantDeleteResponse ' + \ 10451 'meta: ' + repr(self.meta) + ' ' +\ 10452 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 10453 '>' 10454 10455 def to_dict(self): 10456 return { 10457 'meta': self.meta, 10458 'rate_limit': self.rate_limit, 10459 } 10460 10461 @classmethod 10462 def from_dict(cls, d): 10463 return cls( 10464 meta=d.get('meta'), 10465 rate_limit=d.get('rate_limit'), 10466 )
RoleGrantDeleteResponse returns information about a RoleGrant that was deleted.
Deprecated: use Role access rules instead.
View Source
10435 def __init__( 10436 self, 10437 meta=None, 10438 rate_limit=None, 10439 ): 10440 self.meta = meta if meta is not None else None 10441 ''' 10442 Reserved for future use. 10443 ''' 10444 self.rate_limit = rate_limit if rate_limit is not None else None 10445 ''' 10446 Rate limit information. 10447 '''
#
meta
Reserved for future use.
#
rate_limit
Rate limit information.
View Source
10469class RoleGrantGetResponse: 10470 ''' 10471 RoleGrantGetResponse returns a requested RoleGrant. 10472 10473 Deprecated: use Role access rules instead. 10474 ''' 10475 __slots__ = [ 10476 'meta', 10477 'rate_limit', 10478 'role_grant', 10479 ] 10480 10481 def __init__( 10482 self, 10483 meta=None, 10484 rate_limit=None, 10485 role_grant=None, 10486 ): 10487 self.meta = meta if meta is not None else None 10488 ''' 10489 Reserved for future use. 10490 ''' 10491 self.rate_limit = rate_limit if rate_limit is not None else None 10492 ''' 10493 Rate limit information. 10494 ''' 10495 self.role_grant = role_grant if role_grant is not None else None 10496 ''' 10497 The requested RoleGrant. 10498 ''' 10499 10500 def __repr__(self): 10501 return '<sdm.RoleGrantGetResponse ' + \ 10502 'meta: ' + repr(self.meta) + ' ' +\ 10503 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 10504 'role_grant: ' + repr(self.role_grant) + ' ' +\ 10505 '>' 10506 10507 def to_dict(self): 10508 return { 10509 'meta': self.meta, 10510 'rate_limit': self.rate_limit, 10511 'role_grant': self.role_grant, 10512 } 10513 10514 @classmethod 10515 def from_dict(cls, d): 10516 return cls( 10517 meta=d.get('meta'), 10518 rate_limit=d.get('rate_limit'), 10519 role_grant=d.get('role_grant'), 10520 )
RoleGrantGetResponse returns a requested RoleGrant.
Deprecated: use Role access rules instead.
View Source
10481 def __init__( 10482 self, 10483 meta=None, 10484 rate_limit=None, 10485 role_grant=None, 10486 ): 10487 self.meta = meta if meta is not None else None 10488 ''' 10489 Reserved for future use. 10490 ''' 10491 self.rate_limit = rate_limit if rate_limit is not None else None 10492 ''' 10493 Rate limit information. 10494 ''' 10495 self.role_grant = role_grant if role_grant is not None else None 10496 ''' 10497 The requested RoleGrant. 10498 '''
#
meta
Reserved for future use.
#
rate_limit
Rate limit information.
#
role_grant
The requested RoleGrant.
View Source
10523class RoleUpdateResponse: 10524 ''' 10525 RoleUpdateResponse returns the fields of a Role after it has been updated by 10526 a RoleUpdateRequest. 10527 ''' 10528 __slots__ = [ 10529 'meta', 10530 'rate_limit', 10531 'role', 10532 ] 10533 10534 def __init__( 10535 self, 10536 meta=None, 10537 rate_limit=None, 10538 role=None, 10539 ): 10540 self.meta = meta if meta is not None else None 10541 ''' 10542 Reserved for future use. 10543 ''' 10544 self.rate_limit = rate_limit if rate_limit is not None else None 10545 ''' 10546 Rate limit information. 10547 ''' 10548 self.role = role if role is not None else None 10549 ''' 10550 The updated Role. 10551 ''' 10552 10553 def __repr__(self): 10554 return '<sdm.RoleUpdateResponse ' + \ 10555 'meta: ' + repr(self.meta) + ' ' +\ 10556 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 10557 'role: ' + repr(self.role) + ' ' +\ 10558 '>' 10559 10560 def to_dict(self): 10561 return { 10562 'meta': self.meta, 10563 'rate_limit': self.rate_limit, 10564 'role': self.role, 10565 } 10566 10567 @classmethod 10568 def from_dict(cls, d): 10569 return cls( 10570 meta=d.get('meta'), 10571 rate_limit=d.get('rate_limit'), 10572 role=d.get('role'), 10573 )
RoleUpdateResponse returns the fields of a Role after it has been updated by a RoleUpdateRequest.
View Source
10534 def __init__( 10535 self, 10536 meta=None, 10537 rate_limit=None, 10538 role=None, 10539 ): 10540 self.meta = meta if meta is not None else None 10541 ''' 10542 Reserved for future use. 10543 ''' 10544 self.rate_limit = rate_limit if rate_limit is not None else None 10545 ''' 10546 Rate limit information. 10547 ''' 10548 self.role = role if role is not None else None 10549 ''' 10550 The updated Role. 10551 '''
#
meta
Reserved for future use.
#
rate_limit
Rate limit information.
#
role
The updated Role.
View Source
10576class SQLServer: 10577 ''' 10578 10579 ''' 10580 __slots__ = [ 10581 'database', 10582 'egress_filter', 10583 'healthy', 10584 'hostname', 10585 'id', 10586 'name', 10587 'override_database', 10588 'password', 10589 'port', 10590 'port_override', 10591 'schema', 10592 'secret_store_id', 10593 'tags', 10594 'username', 10595 ] 10596 10597 def __init__( 10598 self, 10599 database=None, 10600 egress_filter=None, 10601 healthy=None, 10602 hostname=None, 10603 id=None, 10604 name=None, 10605 override_database=None, 10606 password=None, 10607 port=None, 10608 port_override=None, 10609 schema=None, 10610 secret_store_id=None, 10611 tags=None, 10612 username=None, 10613 ): 10614 self.database = database if database is not None else '' 10615 ''' 10616 10617 ''' 10618 self.egress_filter = egress_filter if egress_filter is not None else '' 10619 ''' 10620 A filter applied to the routing logic to pin datasource to nodes. 10621 ''' 10622 self.healthy = healthy if healthy is not None else False 10623 ''' 10624 True if the datasource is reachable and the credentials are valid. 10625 ''' 10626 self.hostname = hostname if hostname is not None else '' 10627 ''' 10628 10629 ''' 10630 self.id = id if id is not None else '' 10631 ''' 10632 Unique identifier of the Resource. 10633 ''' 10634 self.name = name if name is not None else '' 10635 ''' 10636 Unique human-readable name of the Resource. 10637 ''' 10638 self.override_database = override_database if override_database is not None else False 10639 ''' 10640 10641 ''' 10642 self.password = password if password is not None else '' 10643 ''' 10644 10645 ''' 10646 self.port = port if port is not None else 0 10647 ''' 10648 10649 ''' 10650 self.port_override = port_override if port_override is not None else 0 10651 ''' 10652 10653 ''' 10654 self.schema = schema if schema is not None else '' 10655 ''' 10656 10657 ''' 10658 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 10659 ''' 10660 ID of the secret store containing credentials for this resource, if any. 10661 ''' 10662 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 10663 ''' 10664 Tags is a map of key, value pairs. 10665 ''' 10666 self.username = username if username is not None else '' 10667 ''' 10668 10669 ''' 10670 10671 def __repr__(self): 10672 return '<sdm.SQLServer ' + \ 10673 'database: ' + repr(self.database) + ' ' +\ 10674 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 10675 'healthy: ' + repr(self.healthy) + ' ' +\ 10676 'hostname: ' + repr(self.hostname) + ' ' +\ 10677 'id: ' + repr(self.id) + ' ' +\ 10678 'name: ' + repr(self.name) + ' ' +\ 10679 'override_database: ' + repr(self.override_database) + ' ' +\ 10680 'password: ' + repr(self.password) + ' ' +\ 10681 'port: ' + repr(self.port) + ' ' +\ 10682 'port_override: ' + repr(self.port_override) + ' ' +\ 10683 'schema: ' + repr(self.schema) + ' ' +\ 10684 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 10685 'tags: ' + repr(self.tags) + ' ' +\ 10686 'username: ' + repr(self.username) + ' ' +\ 10687 '>' 10688 10689 def to_dict(self): 10690 return { 10691 'database': self.database, 10692 'egress_filter': self.egress_filter, 10693 'healthy': self.healthy, 10694 'hostname': self.hostname, 10695 'id': self.id, 10696 'name': self.name, 10697 'override_database': self.override_database, 10698 'password': self.password, 10699 'port': self.port, 10700 'port_override': self.port_override, 10701 'schema': self.schema, 10702 'secret_store_id': self.secret_store_id, 10703 'tags': self.tags, 10704 'username': self.username, 10705 } 10706 10707 @classmethod 10708 def from_dict(cls, d): 10709 return cls( 10710 database=d.get('database'), 10711 egress_filter=d.get('egress_filter'), 10712 healthy=d.get('healthy'), 10713 hostname=d.get('hostname'), 10714 id=d.get('id'), 10715 name=d.get('name'), 10716 override_database=d.get('override_database'), 10717 password=d.get('password'), 10718 port=d.get('port'), 10719 port_override=d.get('port_override'), 10720 schema=d.get('schema'), 10721 secret_store_id=d.get('secret_store_id'), 10722 tags=d.get('tags'), 10723 username=d.get('username'), 10724 )
#
SQLServer(
database=None,
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
override_database=None,
password=None,
port=None,
port_override=None,
schema=None,
secret_store_id=None,
tags=None,
username=None
)
View Source
10597 def __init__( 10598 self, 10599 database=None, 10600 egress_filter=None, 10601 healthy=None, 10602 hostname=None, 10603 id=None, 10604 name=None, 10605 override_database=None, 10606 password=None, 10607 port=None, 10608 port_override=None, 10609 schema=None, 10610 secret_store_id=None, 10611 tags=None, 10612 username=None, 10613 ): 10614 self.database = database if database is not None else '' 10615 ''' 10616 10617 ''' 10618 self.egress_filter = egress_filter if egress_filter is not None else '' 10619 ''' 10620 A filter applied to the routing logic to pin datasource to nodes. 10621 ''' 10622 self.healthy = healthy if healthy is not None else False 10623 ''' 10624 True if the datasource is reachable and the credentials are valid. 10625 ''' 10626 self.hostname = hostname if hostname is not None else '' 10627 ''' 10628 10629 ''' 10630 self.id = id if id is not None else '' 10631 ''' 10632 Unique identifier of the Resource. 10633 ''' 10634 self.name = name if name is not None else '' 10635 ''' 10636 Unique human-readable name of the Resource. 10637 ''' 10638 self.override_database = override_database if override_database is not None else False 10639 ''' 10640 10641 ''' 10642 self.password = password if password is not None else '' 10643 ''' 10644 10645 ''' 10646 self.port = port if port is not None else 0 10647 ''' 10648 10649 ''' 10650 self.port_override = port_override if port_override is not None else 0 10651 ''' 10652 10653 ''' 10654 self.schema = schema if schema is not None else '' 10655 ''' 10656 10657 ''' 10658 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 10659 ''' 10660 ID of the secret store containing credentials for this resource, if any. 10661 ''' 10662 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 10663 ''' 10664 Tags is a map of key, value pairs. 10665 ''' 10666 self.username = username if username is not None else '' 10667 ''' 10668 10669 '''
#
database
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
override_database
#
password
#
port
#
port_override
#
schema
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
username
View Source
10689 def to_dict(self): 10690 return { 10691 'database': self.database, 10692 'egress_filter': self.egress_filter, 10693 'healthy': self.healthy, 10694 'hostname': self.hostname, 10695 'id': self.id, 10696 'name': self.name, 10697 'override_database': self.override_database, 10698 'password': self.password, 10699 'port': self.port, 10700 'port_override': self.port_override, 10701 'schema': self.schema, 10702 'secret_store_id': self.secret_store_id, 10703 'tags': self.tags, 10704 'username': self.username, 10705 }
View Source
10707 @classmethod 10708 def from_dict(cls, d): 10709 return cls( 10710 database=d.get('database'), 10711 egress_filter=d.get('egress_filter'), 10712 healthy=d.get('healthy'), 10713 hostname=d.get('hostname'), 10714 id=d.get('id'), 10715 name=d.get('name'), 10716 override_database=d.get('override_database'), 10717 password=d.get('password'), 10718 port=d.get('port'), 10719 port_override=d.get('port_override'), 10720 schema=d.get('schema'), 10721 secret_store_id=d.get('secret_store_id'), 10722 tags=d.get('tags'), 10723 username=d.get('username'), 10724 )
View Source
10727class SSH: 10728 ''' 10729 10730 ''' 10731 __slots__ = [ 10732 'allow_deprecated_key_exchanges', 10733 'egress_filter', 10734 'healthy', 10735 'hostname', 10736 'id', 10737 'name', 10738 'port', 10739 'port_forwarding', 10740 'public_key', 10741 'secret_store_id', 10742 'tags', 10743 'username', 10744 ] 10745 10746 def __init__( 10747 self, 10748 allow_deprecated_key_exchanges=None, 10749 egress_filter=None, 10750 healthy=None, 10751 hostname=None, 10752 id=None, 10753 name=None, 10754 port=None, 10755 port_forwarding=None, 10756 public_key=None, 10757 secret_store_id=None, 10758 tags=None, 10759 username=None, 10760 ): 10761 self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False 10762 ''' 10763 10764 ''' 10765 self.egress_filter = egress_filter if egress_filter is not None else '' 10766 ''' 10767 A filter applied to the routing logic to pin datasource to nodes. 10768 ''' 10769 self.healthy = healthy if healthy is not None else False 10770 ''' 10771 True if the datasource is reachable and the credentials are valid. 10772 ''' 10773 self.hostname = hostname if hostname is not None else '' 10774 ''' 10775 10776 ''' 10777 self.id = id if id is not None else '' 10778 ''' 10779 Unique identifier of the Resource. 10780 ''' 10781 self.name = name if name is not None else '' 10782 ''' 10783 Unique human-readable name of the Resource. 10784 ''' 10785 self.port = port if port is not None else 0 10786 ''' 10787 10788 ''' 10789 self.port_forwarding = port_forwarding if port_forwarding is not None else False 10790 ''' 10791 10792 ''' 10793 self.public_key = public_key if public_key is not None else '' 10794 ''' 10795 10796 ''' 10797 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 10798 ''' 10799 ID of the secret store containing credentials for this resource, if any. 10800 ''' 10801 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 10802 ''' 10803 Tags is a map of key, value pairs. 10804 ''' 10805 self.username = username if username is not None else '' 10806 ''' 10807 10808 ''' 10809 10810 def __repr__(self): 10811 return '<sdm.SSH ' + \ 10812 'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\ 10813 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 10814 'healthy: ' + repr(self.healthy) + ' ' +\ 10815 'hostname: ' + repr(self.hostname) + ' ' +\ 10816 'id: ' + repr(self.id) + ' ' +\ 10817 'name: ' + repr(self.name) + ' ' +\ 10818 'port: ' + repr(self.port) + ' ' +\ 10819 'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\ 10820 'public_key: ' + repr(self.public_key) + ' ' +\ 10821 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 10822 'tags: ' + repr(self.tags) + ' ' +\ 10823 'username: ' + repr(self.username) + ' ' +\ 10824 '>' 10825 10826 def to_dict(self): 10827 return { 10828 'allow_deprecated_key_exchanges': 10829 self.allow_deprecated_key_exchanges, 10830 'egress_filter': self.egress_filter, 10831 'healthy': self.healthy, 10832 'hostname': self.hostname, 10833 'id': self.id, 10834 'name': self.name, 10835 'port': self.port, 10836 'port_forwarding': self.port_forwarding, 10837 'public_key': self.public_key, 10838 'secret_store_id': self.secret_store_id, 10839 'tags': self.tags, 10840 'username': self.username, 10841 } 10842 10843 @classmethod 10844 def from_dict(cls, d): 10845 return cls( 10846 allow_deprecated_key_exchanges=d.get( 10847 'allow_deprecated_key_exchanges'), 10848 egress_filter=d.get('egress_filter'), 10849 healthy=d.get('healthy'), 10850 hostname=d.get('hostname'), 10851 id=d.get('id'), 10852 name=d.get('name'), 10853 port=d.get('port'), 10854 port_forwarding=d.get('port_forwarding'), 10855 public_key=d.get('public_key'), 10856 secret_store_id=d.get('secret_store_id'), 10857 tags=d.get('tags'), 10858 username=d.get('username'), 10859 )
#
SSH(
allow_deprecated_key_exchanges=None,
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
port=None,
port_forwarding=None,
public_key=None,
secret_store_id=None,
tags=None,
username=None
)
View Source
10746 def __init__( 10747 self, 10748 allow_deprecated_key_exchanges=None, 10749 egress_filter=None, 10750 healthy=None, 10751 hostname=None, 10752 id=None, 10753 name=None, 10754 port=None, 10755 port_forwarding=None, 10756 public_key=None, 10757 secret_store_id=None, 10758 tags=None, 10759 username=None, 10760 ): 10761 self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False 10762 ''' 10763 10764 ''' 10765 self.egress_filter = egress_filter if egress_filter is not None else '' 10766 ''' 10767 A filter applied to the routing logic to pin datasource to nodes. 10768 ''' 10769 self.healthy = healthy if healthy is not None else False 10770 ''' 10771 True if the datasource is reachable and the credentials are valid. 10772 ''' 10773 self.hostname = hostname if hostname is not None else '' 10774 ''' 10775 10776 ''' 10777 self.id = id if id is not None else '' 10778 ''' 10779 Unique identifier of the Resource. 10780 ''' 10781 self.name = name if name is not None else '' 10782 ''' 10783 Unique human-readable name of the Resource. 10784 ''' 10785 self.port = port if port is not None else 0 10786 ''' 10787 10788 ''' 10789 self.port_forwarding = port_forwarding if port_forwarding is not None else False 10790 ''' 10791 10792 ''' 10793 self.public_key = public_key if public_key is not None else '' 10794 ''' 10795 10796 ''' 10797 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 10798 ''' 10799 ID of the secret store containing credentials for this resource, if any. 10800 ''' 10801 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 10802 ''' 10803 Tags is a map of key, value pairs. 10804 ''' 10805 self.username = username if username is not None else '' 10806 ''' 10807 10808 '''
#
allow_deprecated_key_exchanges
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
port
#
port_forwarding
#
public_key
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
username
View Source
10826 def to_dict(self): 10827 return { 10828 'allow_deprecated_key_exchanges': 10829 self.allow_deprecated_key_exchanges, 10830 'egress_filter': self.egress_filter, 10831 'healthy': self.healthy, 10832 'hostname': self.hostname, 10833 'id': self.id, 10834 'name': self.name, 10835 'port': self.port, 10836 'port_forwarding': self.port_forwarding, 10837 'public_key': self.public_key, 10838 'secret_store_id': self.secret_store_id, 10839 'tags': self.tags, 10840 'username': self.username, 10841 }
View Source
10843 @classmethod 10844 def from_dict(cls, d): 10845 return cls( 10846 allow_deprecated_key_exchanges=d.get( 10847 'allow_deprecated_key_exchanges'), 10848 egress_filter=d.get('egress_filter'), 10849 healthy=d.get('healthy'), 10850 hostname=d.get('hostname'), 10851 id=d.get('id'), 10852 name=d.get('name'), 10853 port=d.get('port'), 10854 port_forwarding=d.get('port_forwarding'), 10855 public_key=d.get('public_key'), 10856 secret_store_id=d.get('secret_store_id'), 10857 tags=d.get('tags'), 10858 username=d.get('username'), 10859 )
View Source
10862class SSHCert: 10863 ''' 10864 10865 ''' 10866 __slots__ = [ 10867 'allow_deprecated_key_exchanges', 10868 'egress_filter', 10869 'healthy', 10870 'hostname', 10871 'id', 10872 'name', 10873 'port', 10874 'port_forwarding', 10875 'secret_store_id', 10876 'tags', 10877 'username', 10878 ] 10879 10880 def __init__( 10881 self, 10882 allow_deprecated_key_exchanges=None, 10883 egress_filter=None, 10884 healthy=None, 10885 hostname=None, 10886 id=None, 10887 name=None, 10888 port=None, 10889 port_forwarding=None, 10890 secret_store_id=None, 10891 tags=None, 10892 username=None, 10893 ): 10894 self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False 10895 ''' 10896 10897 ''' 10898 self.egress_filter = egress_filter if egress_filter is not None else '' 10899 ''' 10900 A filter applied to the routing logic to pin datasource to nodes. 10901 ''' 10902 self.healthy = healthy if healthy is not None else False 10903 ''' 10904 True if the datasource is reachable and the credentials are valid. 10905 ''' 10906 self.hostname = hostname if hostname is not None else '' 10907 ''' 10908 10909 ''' 10910 self.id = id if id is not None else '' 10911 ''' 10912 Unique identifier of the Resource. 10913 ''' 10914 self.name = name if name is not None else '' 10915 ''' 10916 Unique human-readable name of the Resource. 10917 ''' 10918 self.port = port if port is not None else 0 10919 ''' 10920 10921 ''' 10922 self.port_forwarding = port_forwarding if port_forwarding is not None else False 10923 ''' 10924 10925 ''' 10926 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 10927 ''' 10928 ID of the secret store containing credentials for this resource, if any. 10929 ''' 10930 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 10931 ''' 10932 Tags is a map of key, value pairs. 10933 ''' 10934 self.username = username if username is not None else '' 10935 ''' 10936 10937 ''' 10938 10939 def __repr__(self): 10940 return '<sdm.SSHCert ' + \ 10941 'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\ 10942 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 10943 'healthy: ' + repr(self.healthy) + ' ' +\ 10944 'hostname: ' + repr(self.hostname) + ' ' +\ 10945 'id: ' + repr(self.id) + ' ' +\ 10946 'name: ' + repr(self.name) + ' ' +\ 10947 'port: ' + repr(self.port) + ' ' +\ 10948 'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\ 10949 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 10950 'tags: ' + repr(self.tags) + ' ' +\ 10951 'username: ' + repr(self.username) + ' ' +\ 10952 '>' 10953 10954 def to_dict(self): 10955 return { 10956 'allow_deprecated_key_exchanges': 10957 self.allow_deprecated_key_exchanges, 10958 'egress_filter': self.egress_filter, 10959 'healthy': self.healthy, 10960 'hostname': self.hostname, 10961 'id': self.id, 10962 'name': self.name, 10963 'port': self.port, 10964 'port_forwarding': self.port_forwarding, 10965 'secret_store_id': self.secret_store_id, 10966 'tags': self.tags, 10967 'username': self.username, 10968 } 10969 10970 @classmethod 10971 def from_dict(cls, d): 10972 return cls( 10973 allow_deprecated_key_exchanges=d.get( 10974 'allow_deprecated_key_exchanges'), 10975 egress_filter=d.get('egress_filter'), 10976 healthy=d.get('healthy'), 10977 hostname=d.get('hostname'), 10978 id=d.get('id'), 10979 name=d.get('name'), 10980 port=d.get('port'), 10981 port_forwarding=d.get('port_forwarding'), 10982 secret_store_id=d.get('secret_store_id'), 10983 tags=d.get('tags'), 10984 username=d.get('username'), 10985 )
#
SSHCert(
allow_deprecated_key_exchanges=None,
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
port=None,
port_forwarding=None,
secret_store_id=None,
tags=None,
username=None
)
View Source
10880 def __init__( 10881 self, 10882 allow_deprecated_key_exchanges=None, 10883 egress_filter=None, 10884 healthy=None, 10885 hostname=None, 10886 id=None, 10887 name=None, 10888 port=None, 10889 port_forwarding=None, 10890 secret_store_id=None, 10891 tags=None, 10892 username=None, 10893 ): 10894 self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False 10895 ''' 10896 10897 ''' 10898 self.egress_filter = egress_filter if egress_filter is not None else '' 10899 ''' 10900 A filter applied to the routing logic to pin datasource to nodes. 10901 ''' 10902 self.healthy = healthy if healthy is not None else False 10903 ''' 10904 True if the datasource is reachable and the credentials are valid. 10905 ''' 10906 self.hostname = hostname if hostname is not None else '' 10907 ''' 10908 10909 ''' 10910 self.id = id if id is not None else '' 10911 ''' 10912 Unique identifier of the Resource. 10913 ''' 10914 self.name = name if name is not None else '' 10915 ''' 10916 Unique human-readable name of the Resource. 10917 ''' 10918 self.port = port if port is not None else 0 10919 ''' 10920 10921 ''' 10922 self.port_forwarding = port_forwarding if port_forwarding is not None else False 10923 ''' 10924 10925 ''' 10926 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 10927 ''' 10928 ID of the secret store containing credentials for this resource, if any. 10929 ''' 10930 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 10931 ''' 10932 Tags is a map of key, value pairs. 10933 ''' 10934 self.username = username if username is not None else '' 10935 ''' 10936 10937 '''
#
allow_deprecated_key_exchanges
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
port
#
port_forwarding
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
username
View Source
10954 def to_dict(self): 10955 return { 10956 'allow_deprecated_key_exchanges': 10957 self.allow_deprecated_key_exchanges, 10958 'egress_filter': self.egress_filter, 10959 'healthy': self.healthy, 10960 'hostname': self.hostname, 10961 'id': self.id, 10962 'name': self.name, 10963 'port': self.port, 10964 'port_forwarding': self.port_forwarding, 10965 'secret_store_id': self.secret_store_id, 10966 'tags': self.tags, 10967 'username': self.username, 10968 }
View Source
10970 @classmethod 10971 def from_dict(cls, d): 10972 return cls( 10973 allow_deprecated_key_exchanges=d.get( 10974 'allow_deprecated_key_exchanges'), 10975 egress_filter=d.get('egress_filter'), 10976 healthy=d.get('healthy'), 10977 hostname=d.get('hostname'), 10978 id=d.get('id'), 10979 name=d.get('name'), 10980 port=d.get('port'), 10981 port_forwarding=d.get('port_forwarding'), 10982 secret_store_id=d.get('secret_store_id'), 10983 tags=d.get('tags'), 10984 username=d.get('username'), 10985 )
View Source
10988class SSHCustomerKey: 10989 ''' 10990 10991 ''' 10992 __slots__ = [ 10993 'allow_deprecated_key_exchanges', 10994 'egress_filter', 10995 'healthy', 10996 'hostname', 10997 'id', 10998 'name', 10999 'port', 11000 'port_forwarding', 11001 'private_key', 11002 'secret_store_id', 11003 'tags', 11004 'username', 11005 ] 11006 11007 def __init__( 11008 self, 11009 allow_deprecated_key_exchanges=None, 11010 egress_filter=None, 11011 healthy=None, 11012 hostname=None, 11013 id=None, 11014 name=None, 11015 port=None, 11016 port_forwarding=None, 11017 private_key=None, 11018 secret_store_id=None, 11019 tags=None, 11020 username=None, 11021 ): 11022 self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False 11023 ''' 11024 11025 ''' 11026 self.egress_filter = egress_filter if egress_filter is not None else '' 11027 ''' 11028 A filter applied to the routing logic to pin datasource to nodes. 11029 ''' 11030 self.healthy = healthy if healthy is not None else False 11031 ''' 11032 True if the datasource is reachable and the credentials are valid. 11033 ''' 11034 self.hostname = hostname if hostname is not None else '' 11035 ''' 11036 11037 ''' 11038 self.id = id if id is not None else '' 11039 ''' 11040 Unique identifier of the Resource. 11041 ''' 11042 self.name = name if name is not None else '' 11043 ''' 11044 Unique human-readable name of the Resource. 11045 ''' 11046 self.port = port if port is not None else 0 11047 ''' 11048 11049 ''' 11050 self.port_forwarding = port_forwarding if port_forwarding is not None else False 11051 ''' 11052 11053 ''' 11054 self.private_key = private_key if private_key is not None else '' 11055 ''' 11056 11057 ''' 11058 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 11059 ''' 11060 ID of the secret store containing credentials for this resource, if any. 11061 ''' 11062 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 11063 ''' 11064 Tags is a map of key, value pairs. 11065 ''' 11066 self.username = username if username is not None else '' 11067 ''' 11068 11069 ''' 11070 11071 def __repr__(self): 11072 return '<sdm.SSHCustomerKey ' + \ 11073 'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\ 11074 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 11075 'healthy: ' + repr(self.healthy) + ' ' +\ 11076 'hostname: ' + repr(self.hostname) + ' ' +\ 11077 'id: ' + repr(self.id) + ' ' +\ 11078 'name: ' + repr(self.name) + ' ' +\ 11079 'port: ' + repr(self.port) + ' ' +\ 11080 'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\ 11081 'private_key: ' + repr(self.private_key) + ' ' +\ 11082 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 11083 'tags: ' + repr(self.tags) + ' ' +\ 11084 'username: ' + repr(self.username) + ' ' +\ 11085 '>' 11086 11087 def to_dict(self): 11088 return { 11089 'allow_deprecated_key_exchanges': 11090 self.allow_deprecated_key_exchanges, 11091 'egress_filter': self.egress_filter, 11092 'healthy': self.healthy, 11093 'hostname': self.hostname, 11094 'id': self.id, 11095 'name': self.name, 11096 'port': self.port, 11097 'port_forwarding': self.port_forwarding, 11098 'private_key': self.private_key, 11099 'secret_store_id': self.secret_store_id, 11100 'tags': self.tags, 11101 'username': self.username, 11102 } 11103 11104 @classmethod 11105 def from_dict(cls, d): 11106 return cls( 11107 allow_deprecated_key_exchanges=d.get( 11108 'allow_deprecated_key_exchanges'), 11109 egress_filter=d.get('egress_filter'), 11110 healthy=d.get('healthy'), 11111 hostname=d.get('hostname'), 11112 id=d.get('id'), 11113 name=d.get('name'), 11114 port=d.get('port'), 11115 port_forwarding=d.get('port_forwarding'), 11116 private_key=d.get('private_key'), 11117 secret_store_id=d.get('secret_store_id'), 11118 tags=d.get('tags'), 11119 username=d.get('username'), 11120 )
#
SSHCustomerKey(
allow_deprecated_key_exchanges=None,
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
port=None,
port_forwarding=None,
private_key=None,
secret_store_id=None,
tags=None,
username=None
)
View Source
11007 def __init__( 11008 self, 11009 allow_deprecated_key_exchanges=None, 11010 egress_filter=None, 11011 healthy=None, 11012 hostname=None, 11013 id=None, 11014 name=None, 11015 port=None, 11016 port_forwarding=None, 11017 private_key=None, 11018 secret_store_id=None, 11019 tags=None, 11020 username=None, 11021 ): 11022 self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False 11023 ''' 11024 11025 ''' 11026 self.egress_filter = egress_filter if egress_filter is not None else '' 11027 ''' 11028 A filter applied to the routing logic to pin datasource to nodes. 11029 ''' 11030 self.healthy = healthy if healthy is not None else False 11031 ''' 11032 True if the datasource is reachable and the credentials are valid. 11033 ''' 11034 self.hostname = hostname if hostname is not None else '' 11035 ''' 11036 11037 ''' 11038 self.id = id if id is not None else '' 11039 ''' 11040 Unique identifier of the Resource. 11041 ''' 11042 self.name = name if name is not None else '' 11043 ''' 11044 Unique human-readable name of the Resource. 11045 ''' 11046 self.port = port if port is not None else 0 11047 ''' 11048 11049 ''' 11050 self.port_forwarding = port_forwarding if port_forwarding is not None else False 11051 ''' 11052 11053 ''' 11054 self.private_key = private_key if private_key is not None else '' 11055 ''' 11056 11057 ''' 11058 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 11059 ''' 11060 ID of the secret store containing credentials for this resource, if any. 11061 ''' 11062 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 11063 ''' 11064 Tags is a map of key, value pairs. 11065 ''' 11066 self.username = username if username is not None else '' 11067 ''' 11068 11069 '''
#
allow_deprecated_key_exchanges
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
port
#
port_forwarding
#
private_key
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
username
View Source
11087 def to_dict(self): 11088 return { 11089 'allow_deprecated_key_exchanges': 11090 self.allow_deprecated_key_exchanges, 11091 'egress_filter': self.egress_filter, 11092 'healthy': self.healthy, 11093 'hostname': self.hostname, 11094 'id': self.id, 11095 'name': self.name, 11096 'port': self.port, 11097 'port_forwarding': self.port_forwarding, 11098 'private_key': self.private_key, 11099 'secret_store_id': self.secret_store_id, 11100 'tags': self.tags, 11101 'username': self.username, 11102 }
View Source
11104 @classmethod 11105 def from_dict(cls, d): 11106 return cls( 11107 allow_deprecated_key_exchanges=d.get( 11108 'allow_deprecated_key_exchanges'), 11109 egress_filter=d.get('egress_filter'), 11110 healthy=d.get('healthy'), 11111 hostname=d.get('hostname'), 11112 id=d.get('id'), 11113 name=d.get('name'), 11114 port=d.get('port'), 11115 port_forwarding=d.get('port_forwarding'), 11116 private_key=d.get('private_key'), 11117 secret_store_id=d.get('secret_store_id'), 11118 tags=d.get('tags'), 11119 username=d.get('username'), 11120 )
View Source
11123class SecretStoreCreateResponse: 11124 ''' 11125 SecretStoreCreateResponse reports how the SecretStores were created in the system. 11126 ''' 11127 __slots__ = [ 11128 'meta', 11129 'rate_limit', 11130 'secret_store', 11131 ] 11132 11133 def __init__( 11134 self, 11135 meta=None, 11136 rate_limit=None, 11137 secret_store=None, 11138 ): 11139 self.meta = meta if meta is not None else None 11140 ''' 11141 Reserved for future use. 11142 ''' 11143 self.rate_limit = rate_limit if rate_limit is not None else None 11144 ''' 11145 Rate limit information. 11146 ''' 11147 self.secret_store = secret_store if secret_store is not None else None 11148 ''' 11149 The created SecretStore. 11150 ''' 11151 11152 def __repr__(self): 11153 return '<sdm.SecretStoreCreateResponse ' + \ 11154 'meta: ' + repr(self.meta) + ' ' +\ 11155 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 11156 'secret_store: ' + repr(self.secret_store) + ' ' +\ 11157 '>' 11158 11159 def to_dict(self): 11160 return { 11161 'meta': self.meta, 11162 'rate_limit': self.rate_limit, 11163 'secret_store': self.secret_store, 11164 } 11165 11166 @classmethod 11167 def from_dict(cls, d): 11168 return cls( 11169 meta=d.get('meta'), 11170 rate_limit=d.get('rate_limit'), 11171 secret_store=d.get('secret_store'), 11172 )
SecretStoreCreateResponse reports how the SecretStores were created in the system.
View Source
11133 def __init__( 11134 self, 11135 meta=None, 11136 rate_limit=None, 11137 secret_store=None, 11138 ): 11139 self.meta = meta if meta is not None else None 11140 ''' 11141 Reserved for future use. 11142 ''' 11143 self.rate_limit = rate_limit if rate_limit is not None else None 11144 ''' 11145 Rate limit information. 11146 ''' 11147 self.secret_store = secret_store if secret_store is not None else None 11148 ''' 11149 The created SecretStore. 11150 '''
#
meta
Reserved for future use.
#
rate_limit
Rate limit information.
#
secret_store
The created SecretStore.
View Source
11175class SecretStoreDeleteResponse: 11176 ''' 11177 SecretStoreDeleteResponse returns information about a SecretStore that was deleted. 11178 ''' 11179 __slots__ = [ 11180 'meta', 11181 'rate_limit', 11182 ] 11183 11184 def __init__( 11185 self, 11186 meta=None, 11187 rate_limit=None, 11188 ): 11189 self.meta = meta if meta is not None else None 11190 ''' 11191 Reserved for future use. 11192 ''' 11193 self.rate_limit = rate_limit if rate_limit is not None else None 11194 ''' 11195 Rate limit information. 11196 ''' 11197 11198 def __repr__(self): 11199 return '<sdm.SecretStoreDeleteResponse ' + \ 11200 'meta: ' + repr(self.meta) + ' ' +\ 11201 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 11202 '>' 11203 11204 def to_dict(self): 11205 return { 11206 'meta': self.meta, 11207 'rate_limit': self.rate_limit, 11208 } 11209 11210 @classmethod 11211 def from_dict(cls, d): 11212 return cls( 11213 meta=d.get('meta'), 11214 rate_limit=d.get('rate_limit'), 11215 )
SecretStoreDeleteResponse returns information about a SecretStore that was deleted.
View Source
11184 def __init__( 11185 self, 11186 meta=None, 11187 rate_limit=None, 11188 ): 11189 self.meta = meta if meta is not None else None 11190 ''' 11191 Reserved for future use. 11192 ''' 11193 self.rate_limit = rate_limit if rate_limit is not None else None 11194 ''' 11195 Rate limit information. 11196 '''
#
meta
Reserved for future use.
#
rate_limit
Rate limit information.
View Source
11218class SecretStoreGetResponse: 11219 ''' 11220 SecretStoreGetResponse returns a requested SecretStore. 11221 ''' 11222 __slots__ = [ 11223 'meta', 11224 'rate_limit', 11225 'secret_store', 11226 ] 11227 11228 def __init__( 11229 self, 11230 meta=None, 11231 rate_limit=None, 11232 secret_store=None, 11233 ): 11234 self.meta = meta if meta is not None else None 11235 ''' 11236 Reserved for future use. 11237 ''' 11238 self.rate_limit = rate_limit if rate_limit is not None else None 11239 ''' 11240 Rate limit information. 11241 ''' 11242 self.secret_store = secret_store if secret_store is not None else None 11243 ''' 11244 The requested SecretStore. 11245 ''' 11246 11247 def __repr__(self): 11248 return '<sdm.SecretStoreGetResponse ' + \ 11249 'meta: ' + repr(self.meta) + ' ' +\ 11250 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 11251 'secret_store: ' + repr(self.secret_store) + ' ' +\ 11252 '>' 11253 11254 def to_dict(self): 11255 return { 11256 'meta': self.meta, 11257 'rate_limit': self.rate_limit, 11258 'secret_store': self.secret_store, 11259 } 11260 11261 @classmethod 11262 def from_dict(cls, d): 11263 return cls( 11264 meta=d.get('meta'), 11265 rate_limit=d.get('rate_limit'), 11266 secret_store=d.get('secret_store'), 11267 )
SecretStoreGetResponse returns a requested SecretStore.
View Source
11228 def __init__( 11229 self, 11230 meta=None, 11231 rate_limit=None, 11232 secret_store=None, 11233 ): 11234 self.meta = meta if meta is not None else None 11235 ''' 11236 Reserved for future use. 11237 ''' 11238 self.rate_limit = rate_limit if rate_limit is not None else None 11239 ''' 11240 Rate limit information. 11241 ''' 11242 self.secret_store = secret_store if secret_store is not None else None 11243 ''' 11244 The requested SecretStore. 11245 '''
#
meta
Reserved for future use.
#
rate_limit
Rate limit information.
#
secret_store
The requested SecretStore.
View Source
11270class SecretStoreUpdateResponse: 11271 ''' 11272 SecretStoreUpdateResponse returns the fields of a SecretStore after it has been updated by 11273 a SecretStoreUpdateRequest. 11274 ''' 11275 __slots__ = [ 11276 'meta', 11277 'rate_limit', 11278 'secret_store', 11279 ] 11280 11281 def __init__( 11282 self, 11283 meta=None, 11284 rate_limit=None, 11285 secret_store=None, 11286 ): 11287 self.meta = meta if meta is not None else None 11288 ''' 11289 Reserved for future use. 11290 ''' 11291 self.rate_limit = rate_limit if rate_limit is not None else None 11292 ''' 11293 Rate limit information. 11294 ''' 11295 self.secret_store = secret_store if secret_store is not None else None 11296 ''' 11297 The updated SecretStore. 11298 ''' 11299 11300 def __repr__(self): 11301 return '<sdm.SecretStoreUpdateResponse ' + \ 11302 'meta: ' + repr(self.meta) + ' ' +\ 11303 'rate_limit: ' + repr(self.rate_limit) + ' ' +\ 11304 'secret_store: ' + repr(self.secret_store) + ' ' +\ 11305 '>' 11306 11307 def to_dict(self): 11308 return { 11309 'meta': self.meta, 11310 'rate_limit': self.rate_limit, 11311 'secret_store': self.secret_store, 11312 } 11313 11314 @classmethod 11315 def from_dict(cls, d): 11316 return cls( 11317 meta=d.get('meta'), 11318 rate_limit=d.get('rate_limit'), 11319 secret_store=d.get('secret_store'), 11320 )
SecretStoreUpdateResponse returns the fields of a SecretStore after it has been updated by a SecretStoreUpdateRequest.
View Source
11281 def __init__( 11282 self, 11283 meta=None, 11284 rate_limit=None, 11285 secret_store=None, 11286 ): 11287 self.meta = meta if meta is not None else None 11288 ''' 11289 Reserved for future use. 11290 ''' 11291 self.rate_limit = rate_limit if rate_limit is not None else None 11292 ''' 11293 Rate limit information. 11294 ''' 11295 self.secret_store = secret_store if secret_store is not None else None 11296 ''' 11297 The updated SecretStore. 11298 '''
#
meta
Reserved for future use.
#
rate_limit
Rate limit information.
#
secret_store
The updated SecretStore.
View Source
11323class Service: 11324 ''' 11325 A Service is a service account that can connect to resources they are granted 11326 directly, or granted via roles. Services are typically automated jobs. 11327 ''' 11328 __slots__ = [ 11329 'id', 11330 'name', 11331 'suspended', 11332 'tags', 11333 ] 11334 11335 def __init__( 11336 self, 11337 id=None, 11338 name=None, 11339 suspended=None, 11340 tags=None, 11341 ): 11342 self.id = id if id is not None else '' 11343 ''' 11344 Unique identifier of the Service. 11345 ''' 11346 self.name = name if name is not None else '' 11347 ''' 11348 Unique human-readable name of the Service. 11349 ''' 11350 self.suspended = suspended if suspended is not None else False 11351 ''' 11352 The Service's suspended state. 11353 ''' 11354 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 11355 ''' 11356 Tags is a map of key, value pairs. 11357 ''' 11358 11359 def __repr__(self): 11360 return '<sdm.Service ' + \ 11361 'id: ' + repr(self.id) + ' ' +\ 11362 'name: ' + repr(self.name) + ' ' +\ 11363 'suspended: ' + repr(self.suspended) + ' ' +\ 11364 'tags: ' + repr(self.tags) + ' ' +\ 11365 '>' 11366 11367 def to_dict(self): 11368 return { 11369 'id': self.id, 11370 'name': self.name, 11371 'suspended': self.suspended, 11372 'tags': self.tags, 11373 } 11374 11375 @classmethod 11376 def from_dict(cls, d): 11377 return cls( 11378 id=d.get('id'), 11379 name=d.get('name'), 11380 suspended=d.get('suspended'), 11381 tags=d.get('tags'), 11382 )
A Service is a service account that can connect to resources they are granted directly, or granted via roles. Services are typically automated jobs.
View Source
11335 def __init__( 11336 self, 11337 id=None, 11338 name=None, 11339 suspended=None, 11340 tags=None, 11341 ): 11342 self.id = id if id is not None else '' 11343 ''' 11344 Unique identifier of the Service. 11345 ''' 11346 self.name = name if name is not None else '' 11347 ''' 11348 Unique human-readable name of the Service. 11349 ''' 11350 self.suspended = suspended if suspended is not None else False 11351 ''' 11352 The Service's suspended state. 11353 ''' 11354 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 11355 ''' 11356 Tags is a map of key, value pairs. 11357 '''
#
id
Unique identifier of the Service.
#
name
Unique human-readable name of the Service.
#
suspended
The Service's suspended state.
View Source
11385class SingleStore: 11386 ''' 11387 11388 ''' 11389 __slots__ = [ 11390 'database', 11391 'egress_filter', 11392 'healthy', 11393 'hostname', 11394 'id', 11395 'name', 11396 'password', 11397 'port', 11398 'port_override', 11399 'secret_store_id', 11400 'tags', 11401 'username', 11402 ] 11403 11404 def __init__( 11405 self, 11406 database=None, 11407 egress_filter=None, 11408 healthy=None, 11409 hostname=None, 11410 id=None, 11411 name=None, 11412 password=None, 11413 port=None, 11414 port_override=None, 11415 secret_store_id=None, 11416 tags=None, 11417 username=None, 11418 ): 11419 self.database = database if database is not None else '' 11420 ''' 11421 11422 ''' 11423 self.egress_filter = egress_filter if egress_filter is not None else '' 11424 ''' 11425 A filter applied to the routing logic to pin datasource to nodes. 11426 ''' 11427 self.healthy = healthy if healthy is not None else False 11428 ''' 11429 True if the datasource is reachable and the credentials are valid. 11430 ''' 11431 self.hostname = hostname if hostname is not None else '' 11432 ''' 11433 11434 ''' 11435 self.id = id if id is not None else '' 11436 ''' 11437 Unique identifier of the Resource. 11438 ''' 11439 self.name = name if name is not None else '' 11440 ''' 11441 Unique human-readable name of the Resource. 11442 ''' 11443 self.password = password if password is not None else '' 11444 ''' 11445 11446 ''' 11447 self.port = port if port is not None else 0 11448 ''' 11449 11450 ''' 11451 self.port_override = port_override if port_override is not None else 0 11452 ''' 11453 11454 ''' 11455 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 11456 ''' 11457 ID of the secret store containing credentials for this resource, if any. 11458 ''' 11459 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 11460 ''' 11461 Tags is a map of key, value pairs. 11462 ''' 11463 self.username = username if username is not None else '' 11464 ''' 11465 11466 ''' 11467 11468 def __repr__(self): 11469 return '<sdm.SingleStore ' + \ 11470 'database: ' + repr(self.database) + ' ' +\ 11471 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 11472 'healthy: ' + repr(self.healthy) + ' ' +\ 11473 'hostname: ' + repr(self.hostname) + ' ' +\ 11474 'id: ' + repr(self.id) + ' ' +\ 11475 'name: ' + repr(self.name) + ' ' +\ 11476 'password: ' + repr(self.password) + ' ' +\ 11477 'port: ' + repr(self.port) + ' ' +\ 11478 'port_override: ' + repr(self.port_override) + ' ' +\ 11479 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 11480 'tags: ' + repr(self.tags) + ' ' +\ 11481 'username: ' + repr(self.username) + ' ' +\ 11482 '>' 11483 11484 def to_dict(self): 11485 return { 11486 'database': self.database, 11487 'egress_filter': self.egress_filter, 11488 'healthy': self.healthy, 11489 'hostname': self.hostname, 11490 'id': self.id, 11491 'name': self.name, 11492 'password': self.password, 11493 'port': self.port, 11494 'port_override': self.port_override, 11495 'secret_store_id': self.secret_store_id, 11496 'tags': self.tags, 11497 'username': self.username, 11498 } 11499 11500 @classmethod 11501 def from_dict(cls, d): 11502 return cls( 11503 database=d.get('database'), 11504 egress_filter=d.get('egress_filter'), 11505 healthy=d.get('healthy'), 11506 hostname=d.get('hostname'), 11507 id=d.get('id'), 11508 name=d.get('name'), 11509 password=d.get('password'), 11510 port=d.get('port'), 11511 port_override=d.get('port_override'), 11512 secret_store_id=d.get('secret_store_id'), 11513 tags=d.get('tags'), 11514 username=d.get('username'), 11515 )
#
SingleStore(
database=None,
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
password=None,
port=None,
port_override=None,
secret_store_id=None,
tags=None,
username=None
)
View Source
11404 def __init__( 11405 self, 11406 database=None, 11407 egress_filter=None, 11408 healthy=None, 11409 hostname=None, 11410 id=None, 11411 name=None, 11412 password=None, 11413 port=None, 11414 port_override=None, 11415 secret_store_id=None, 11416 tags=None, 11417 username=None, 11418 ): 11419 self.database = database if database is not None else '' 11420 ''' 11421 11422 ''' 11423 self.egress_filter = egress_filter if egress_filter is not None else '' 11424 ''' 11425 A filter applied to the routing logic to pin datasource to nodes. 11426 ''' 11427 self.healthy = healthy if healthy is not None else False 11428 ''' 11429 True if the datasource is reachable and the credentials are valid. 11430 ''' 11431 self.hostname = hostname if hostname is not None else '' 11432 ''' 11433 11434 ''' 11435 self.id = id if id is not None else '' 11436 ''' 11437 Unique identifier of the Resource. 11438 ''' 11439 self.name = name if name is not None else '' 11440 ''' 11441 Unique human-readable name of the Resource. 11442 ''' 11443 self.password = password if password is not None else '' 11444 ''' 11445 11446 ''' 11447 self.port = port if port is not None else 0 11448 ''' 11449 11450 ''' 11451 self.port_override = port_override if port_override is not None else 0 11452 ''' 11453 11454 ''' 11455 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 11456 ''' 11457 ID of the secret store containing credentials for this resource, if any. 11458 ''' 11459 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 11460 ''' 11461 Tags is a map of key, value pairs. 11462 ''' 11463 self.username = username if username is not None else '' 11464 ''' 11465 11466 '''
#
database
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
password
#
port
#
port_override
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
username
View Source
11484 def to_dict(self): 11485 return { 11486 'database': self.database, 11487 'egress_filter': self.egress_filter, 11488 'healthy': self.healthy, 11489 'hostname': self.hostname, 11490 'id': self.id, 11491 'name': self.name, 11492 'password': self.password, 11493 'port': self.port, 11494 'port_override': self.port_override, 11495 'secret_store_id': self.secret_store_id, 11496 'tags': self.tags, 11497 'username': self.username, 11498 }
View Source
11500 @classmethod 11501 def from_dict(cls, d): 11502 return cls( 11503 database=d.get('database'), 11504 egress_filter=d.get('egress_filter'), 11505 healthy=d.get('healthy'), 11506 hostname=d.get('hostname'), 11507 id=d.get('id'), 11508 name=d.get('name'), 11509 password=d.get('password'), 11510 port=d.get('port'), 11511 port_override=d.get('port_override'), 11512 secret_store_id=d.get('secret_store_id'), 11513 tags=d.get('tags'), 11514 username=d.get('username'), 11515 )
View Source
11518class Snowflake: 11519 ''' 11520 11521 ''' 11522 __slots__ = [ 11523 'database', 11524 'egress_filter', 11525 'healthy', 11526 'hostname', 11527 'id', 11528 'name', 11529 'password', 11530 'port_override', 11531 'schema', 11532 'secret_store_id', 11533 'tags', 11534 'username', 11535 ] 11536 11537 def __init__( 11538 self, 11539 database=None, 11540 egress_filter=None, 11541 healthy=None, 11542 hostname=None, 11543 id=None, 11544 name=None, 11545 password=None, 11546 port_override=None, 11547 schema=None, 11548 secret_store_id=None, 11549 tags=None, 11550 username=None, 11551 ): 11552 self.database = database if database is not None else '' 11553 ''' 11554 11555 ''' 11556 self.egress_filter = egress_filter if egress_filter is not None else '' 11557 ''' 11558 A filter applied to the routing logic to pin datasource to nodes. 11559 ''' 11560 self.healthy = healthy if healthy is not None else False 11561 ''' 11562 True if the datasource is reachable and the credentials are valid. 11563 ''' 11564 self.hostname = hostname if hostname is not None else '' 11565 ''' 11566 11567 ''' 11568 self.id = id if id is not None else '' 11569 ''' 11570 Unique identifier of the Resource. 11571 ''' 11572 self.name = name if name is not None else '' 11573 ''' 11574 Unique human-readable name of the Resource. 11575 ''' 11576 self.password = password if password is not None else '' 11577 ''' 11578 11579 ''' 11580 self.port_override = port_override if port_override is not None else 0 11581 ''' 11582 11583 ''' 11584 self.schema = schema if schema is not None else '' 11585 ''' 11586 11587 ''' 11588 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 11589 ''' 11590 ID of the secret store containing credentials for this resource, if any. 11591 ''' 11592 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 11593 ''' 11594 Tags is a map of key, value pairs. 11595 ''' 11596 self.username = username if username is not None else '' 11597 ''' 11598 11599 ''' 11600 11601 def __repr__(self): 11602 return '<sdm.Snowflake ' + \ 11603 'database: ' + repr(self.database) + ' ' +\ 11604 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 11605 'healthy: ' + repr(self.healthy) + ' ' +\ 11606 'hostname: ' + repr(self.hostname) + ' ' +\ 11607 'id: ' + repr(self.id) + ' ' +\ 11608 'name: ' + repr(self.name) + ' ' +\ 11609 'password: ' + repr(self.password) + ' ' +\ 11610 'port_override: ' + repr(self.port_override) + ' ' +\ 11611 'schema: ' + repr(self.schema) + ' ' +\ 11612 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 11613 'tags: ' + repr(self.tags) + ' ' +\ 11614 'username: ' + repr(self.username) + ' ' +\ 11615 '>' 11616 11617 def to_dict(self): 11618 return { 11619 'database': self.database, 11620 'egress_filter': self.egress_filter, 11621 'healthy': self.healthy, 11622 'hostname': self.hostname, 11623 'id': self.id, 11624 'name': self.name, 11625 'password': self.password, 11626 'port_override': self.port_override, 11627 'schema': self.schema, 11628 'secret_store_id': self.secret_store_id, 11629 'tags': self.tags, 11630 'username': self.username, 11631 } 11632 11633 @classmethod 11634 def from_dict(cls, d): 11635 return cls( 11636 database=d.get('database'), 11637 egress_filter=d.get('egress_filter'), 11638 healthy=d.get('healthy'), 11639 hostname=d.get('hostname'), 11640 id=d.get('id'), 11641 name=d.get('name'), 11642 password=d.get('password'), 11643 port_override=d.get('port_override'), 11644 schema=d.get('schema'), 11645 secret_store_id=d.get('secret_store_id'), 11646 tags=d.get('tags'), 11647 username=d.get('username'), 11648 )
#
Snowflake(
database=None,
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
password=None,
port_override=None,
schema=None,
secret_store_id=None,
tags=None,
username=None
)
View Source
11537 def __init__( 11538 self, 11539 database=None, 11540 egress_filter=None, 11541 healthy=None, 11542 hostname=None, 11543 id=None, 11544 name=None, 11545 password=None, 11546 port_override=None, 11547 schema=None, 11548 secret_store_id=None, 11549 tags=None, 11550 username=None, 11551 ): 11552 self.database = database if database is not None else '' 11553 ''' 11554 11555 ''' 11556 self.egress_filter = egress_filter if egress_filter is not None else '' 11557 ''' 11558 A filter applied to the routing logic to pin datasource to nodes. 11559 ''' 11560 self.healthy = healthy if healthy is not None else False 11561 ''' 11562 True if the datasource is reachable and the credentials are valid. 11563 ''' 11564 self.hostname = hostname if hostname is not None else '' 11565 ''' 11566 11567 ''' 11568 self.id = id if id is not None else '' 11569 ''' 11570 Unique identifier of the Resource. 11571 ''' 11572 self.name = name if name is not None else '' 11573 ''' 11574 Unique human-readable name of the Resource. 11575 ''' 11576 self.password = password if password is not None else '' 11577 ''' 11578 11579 ''' 11580 self.port_override = port_override if port_override is not None else 0 11581 ''' 11582 11583 ''' 11584 self.schema = schema if schema is not None else '' 11585 ''' 11586 11587 ''' 11588 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 11589 ''' 11590 ID of the secret store containing credentials for this resource, if any. 11591 ''' 11592 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 11593 ''' 11594 Tags is a map of key, value pairs. 11595 ''' 11596 self.username = username if username is not None else '' 11597 ''' 11598 11599 '''
#
database
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
password
#
port_override
#
schema
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
username
View Source
11617 def to_dict(self): 11618 return { 11619 'database': self.database, 11620 'egress_filter': self.egress_filter, 11621 'healthy': self.healthy, 11622 'hostname': self.hostname, 11623 'id': self.id, 11624 'name': self.name, 11625 'password': self.password, 11626 'port_override': self.port_override, 11627 'schema': self.schema, 11628 'secret_store_id': self.secret_store_id, 11629 'tags': self.tags, 11630 'username': self.username, 11631 }
View Source
11633 @classmethod 11634 def from_dict(cls, d): 11635 return cls( 11636 database=d.get('database'), 11637 egress_filter=d.get('egress_filter'), 11638 healthy=d.get('healthy'), 11639 hostname=d.get('hostname'), 11640 id=d.get('id'), 11641 name=d.get('name'), 11642 password=d.get('password'), 11643 port_override=d.get('port_override'), 11644 schema=d.get('schema'), 11645 secret_store_id=d.get('secret_store_id'), 11646 tags=d.get('tags'), 11647 username=d.get('username'), 11648 )
View Source
11651class Sybase: 11652 ''' 11653 11654 ''' 11655 __slots__ = [ 11656 'egress_filter', 11657 'healthy', 11658 'hostname', 11659 'id', 11660 'name', 11661 'password', 11662 'port', 11663 'port_override', 11664 'secret_store_id', 11665 'tags', 11666 'username', 11667 ] 11668 11669 def __init__( 11670 self, 11671 egress_filter=None, 11672 healthy=None, 11673 hostname=None, 11674 id=None, 11675 name=None, 11676 password=None, 11677 port=None, 11678 port_override=None, 11679 secret_store_id=None, 11680 tags=None, 11681 username=None, 11682 ): 11683 self.egress_filter = egress_filter if egress_filter is not None else '' 11684 ''' 11685 A filter applied to the routing logic to pin datasource to nodes. 11686 ''' 11687 self.healthy = healthy if healthy is not None else False 11688 ''' 11689 True if the datasource is reachable and the credentials are valid. 11690 ''' 11691 self.hostname = hostname if hostname is not None else '' 11692 ''' 11693 11694 ''' 11695 self.id = id if id is not None else '' 11696 ''' 11697 Unique identifier of the Resource. 11698 ''' 11699 self.name = name if name is not None else '' 11700 ''' 11701 Unique human-readable name of the Resource. 11702 ''' 11703 self.password = password if password is not None else '' 11704 ''' 11705 11706 ''' 11707 self.port = port if port is not None else 0 11708 ''' 11709 11710 ''' 11711 self.port_override = port_override if port_override is not None else 0 11712 ''' 11713 11714 ''' 11715 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 11716 ''' 11717 ID of the secret store containing credentials for this resource, if any. 11718 ''' 11719 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 11720 ''' 11721 Tags is a map of key, value pairs. 11722 ''' 11723 self.username = username if username is not None else '' 11724 ''' 11725 11726 ''' 11727 11728 def __repr__(self): 11729 return '<sdm.Sybase ' + \ 11730 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 11731 'healthy: ' + repr(self.healthy) + ' ' +\ 11732 'hostname: ' + repr(self.hostname) + ' ' +\ 11733 'id: ' + repr(self.id) + ' ' +\ 11734 'name: ' + repr(self.name) + ' ' +\ 11735 'password: ' + repr(self.password) + ' ' +\ 11736 'port: ' + repr(self.port) + ' ' +\ 11737 'port_override: ' + repr(self.port_override) + ' ' +\ 11738 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 11739 'tags: ' + repr(self.tags) + ' ' +\ 11740 'username: ' + repr(self.username) + ' ' +\ 11741 '>' 11742 11743 def to_dict(self): 11744 return { 11745 'egress_filter': self.egress_filter, 11746 'healthy': self.healthy, 11747 'hostname': self.hostname, 11748 'id': self.id, 11749 'name': self.name, 11750 'password': self.password, 11751 'port': self.port, 11752 'port_override': self.port_override, 11753 'secret_store_id': self.secret_store_id, 11754 'tags': self.tags, 11755 'username': self.username, 11756 } 11757 11758 @classmethod 11759 def from_dict(cls, d): 11760 return cls( 11761 egress_filter=d.get('egress_filter'), 11762 healthy=d.get('healthy'), 11763 hostname=d.get('hostname'), 11764 id=d.get('id'), 11765 name=d.get('name'), 11766 password=d.get('password'), 11767 port=d.get('port'), 11768 port_override=d.get('port_override'), 11769 secret_store_id=d.get('secret_store_id'), 11770 tags=d.get('tags'), 11771 username=d.get('username'), 11772 )
#
Sybase(
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
password=None,
port=None,
port_override=None,
secret_store_id=None,
tags=None,
username=None
)
View Source
11669 def __init__( 11670 self, 11671 egress_filter=None, 11672 healthy=None, 11673 hostname=None, 11674 id=None, 11675 name=None, 11676 password=None, 11677 port=None, 11678 port_override=None, 11679 secret_store_id=None, 11680 tags=None, 11681 username=None, 11682 ): 11683 self.egress_filter = egress_filter if egress_filter is not None else '' 11684 ''' 11685 A filter applied to the routing logic to pin datasource to nodes. 11686 ''' 11687 self.healthy = healthy if healthy is not None else False 11688 ''' 11689 True if the datasource is reachable and the credentials are valid. 11690 ''' 11691 self.hostname = hostname if hostname is not None else '' 11692 ''' 11693 11694 ''' 11695 self.id = id if id is not None else '' 11696 ''' 11697 Unique identifier of the Resource. 11698 ''' 11699 self.name = name if name is not None else '' 11700 ''' 11701 Unique human-readable name of the Resource. 11702 ''' 11703 self.password = password if password is not None else '' 11704 ''' 11705 11706 ''' 11707 self.port = port if port is not None else 0 11708 ''' 11709 11710 ''' 11711 self.port_override = port_override if port_override is not None else 0 11712 ''' 11713 11714 ''' 11715 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 11716 ''' 11717 ID of the secret store containing credentials for this resource, if any. 11718 ''' 11719 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 11720 ''' 11721 Tags is a map of key, value pairs. 11722 ''' 11723 self.username = username if username is not None else '' 11724 ''' 11725 11726 '''
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
password
#
port
#
port_override
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
username
View Source
11743 def to_dict(self): 11744 return { 11745 'egress_filter': self.egress_filter, 11746 'healthy': self.healthy, 11747 'hostname': self.hostname, 11748 'id': self.id, 11749 'name': self.name, 11750 'password': self.password, 11751 'port': self.port, 11752 'port_override': self.port_override, 11753 'secret_store_id': self.secret_store_id, 11754 'tags': self.tags, 11755 'username': self.username, 11756 }
View Source
11758 @classmethod 11759 def from_dict(cls, d): 11760 return cls( 11761 egress_filter=d.get('egress_filter'), 11762 healthy=d.get('healthy'), 11763 hostname=d.get('hostname'), 11764 id=d.get('id'), 11765 name=d.get('name'), 11766 password=d.get('password'), 11767 port=d.get('port'), 11768 port_override=d.get('port_override'), 11769 secret_store_id=d.get('secret_store_id'), 11770 tags=d.get('tags'), 11771 username=d.get('username'), 11772 )
View Source
11775class SybaseIQ: 11776 ''' 11777 11778 ''' 11779 __slots__ = [ 11780 'egress_filter', 11781 'healthy', 11782 'hostname', 11783 'id', 11784 'name', 11785 'password', 11786 'port', 11787 'port_override', 11788 'secret_store_id', 11789 'tags', 11790 'username', 11791 ] 11792 11793 def __init__( 11794 self, 11795 egress_filter=None, 11796 healthy=None, 11797 hostname=None, 11798 id=None, 11799 name=None, 11800 password=None, 11801 port=None, 11802 port_override=None, 11803 secret_store_id=None, 11804 tags=None, 11805 username=None, 11806 ): 11807 self.egress_filter = egress_filter if egress_filter is not None else '' 11808 ''' 11809 A filter applied to the routing logic to pin datasource to nodes. 11810 ''' 11811 self.healthy = healthy if healthy is not None else False 11812 ''' 11813 True if the datasource is reachable and the credentials are valid. 11814 ''' 11815 self.hostname = hostname if hostname is not None else '' 11816 ''' 11817 11818 ''' 11819 self.id = id if id is not None else '' 11820 ''' 11821 Unique identifier of the Resource. 11822 ''' 11823 self.name = name if name is not None else '' 11824 ''' 11825 Unique human-readable name of the Resource. 11826 ''' 11827 self.password = password if password is not None else '' 11828 ''' 11829 11830 ''' 11831 self.port = port if port is not None else 0 11832 ''' 11833 11834 ''' 11835 self.port_override = port_override if port_override is not None else 0 11836 ''' 11837 11838 ''' 11839 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 11840 ''' 11841 ID of the secret store containing credentials for this resource, if any. 11842 ''' 11843 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 11844 ''' 11845 Tags is a map of key, value pairs. 11846 ''' 11847 self.username = username if username is not None else '' 11848 ''' 11849 11850 ''' 11851 11852 def __repr__(self): 11853 return '<sdm.SybaseIQ ' + \ 11854 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 11855 'healthy: ' + repr(self.healthy) + ' ' +\ 11856 'hostname: ' + repr(self.hostname) + ' ' +\ 11857 'id: ' + repr(self.id) + ' ' +\ 11858 'name: ' + repr(self.name) + ' ' +\ 11859 'password: ' + repr(self.password) + ' ' +\ 11860 'port: ' + repr(self.port) + ' ' +\ 11861 'port_override: ' + repr(self.port_override) + ' ' +\ 11862 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 11863 'tags: ' + repr(self.tags) + ' ' +\ 11864 'username: ' + repr(self.username) + ' ' +\ 11865 '>' 11866 11867 def to_dict(self): 11868 return { 11869 'egress_filter': self.egress_filter, 11870 'healthy': self.healthy, 11871 'hostname': self.hostname, 11872 'id': self.id, 11873 'name': self.name, 11874 'password': self.password, 11875 'port': self.port, 11876 'port_override': self.port_override, 11877 'secret_store_id': self.secret_store_id, 11878 'tags': self.tags, 11879 'username': self.username, 11880 } 11881 11882 @classmethod 11883 def from_dict(cls, d): 11884 return cls( 11885 egress_filter=d.get('egress_filter'), 11886 healthy=d.get('healthy'), 11887 hostname=d.get('hostname'), 11888 id=d.get('id'), 11889 name=d.get('name'), 11890 password=d.get('password'), 11891 port=d.get('port'), 11892 port_override=d.get('port_override'), 11893 secret_store_id=d.get('secret_store_id'), 11894 tags=d.get('tags'), 11895 username=d.get('username'), 11896 )
#
SybaseIQ(
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
password=None,
port=None,
port_override=None,
secret_store_id=None,
tags=None,
username=None
)
View Source
11793 def __init__( 11794 self, 11795 egress_filter=None, 11796 healthy=None, 11797 hostname=None, 11798 id=None, 11799 name=None, 11800 password=None, 11801 port=None, 11802 port_override=None, 11803 secret_store_id=None, 11804 tags=None, 11805 username=None, 11806 ): 11807 self.egress_filter = egress_filter if egress_filter is not None else '' 11808 ''' 11809 A filter applied to the routing logic to pin datasource to nodes. 11810 ''' 11811 self.healthy = healthy if healthy is not None else False 11812 ''' 11813 True if the datasource is reachable and the credentials are valid. 11814 ''' 11815 self.hostname = hostname if hostname is not None else '' 11816 ''' 11817 11818 ''' 11819 self.id = id if id is not None else '' 11820 ''' 11821 Unique identifier of the Resource. 11822 ''' 11823 self.name = name if name is not None else '' 11824 ''' 11825 Unique human-readable name of the Resource. 11826 ''' 11827 self.password = password if password is not None else '' 11828 ''' 11829 11830 ''' 11831 self.port = port if port is not None else 0 11832 ''' 11833 11834 ''' 11835 self.port_override = port_override if port_override is not None else 0 11836 ''' 11837 11838 ''' 11839 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 11840 ''' 11841 ID of the secret store containing credentials for this resource, if any. 11842 ''' 11843 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 11844 ''' 11845 Tags is a map of key, value pairs. 11846 ''' 11847 self.username = username if username is not None else '' 11848 ''' 11849 11850 '''
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
password
#
port
#
port_override
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
username
View Source
11867 def to_dict(self): 11868 return { 11869 'egress_filter': self.egress_filter, 11870 'healthy': self.healthy, 11871 'hostname': self.hostname, 11872 'id': self.id, 11873 'name': self.name, 11874 'password': self.password, 11875 'port': self.port, 11876 'port_override': self.port_override, 11877 'secret_store_id': self.secret_store_id, 11878 'tags': self.tags, 11879 'username': self.username, 11880 }
View Source
11882 @classmethod 11883 def from_dict(cls, d): 11884 return cls( 11885 egress_filter=d.get('egress_filter'), 11886 healthy=d.get('healthy'), 11887 hostname=d.get('hostname'), 11888 id=d.get('id'), 11889 name=d.get('name'), 11890 password=d.get('password'), 11891 port=d.get('port'), 11892 port_override=d.get('port_override'), 11893 secret_store_id=d.get('secret_store_id'), 11894 tags=d.get('tags'), 11895 username=d.get('username'), 11896 )
View Source
11899class Tag: 11900 ''' 11901 11902 ''' 11903 __slots__ = [ 11904 'name', 11905 'value', 11906 ] 11907 11908 def __init__( 11909 self, 11910 name=None, 11911 value=None, 11912 ): 11913 self.name = name if name is not None else '' 11914 ''' 11915 11916 ''' 11917 self.value = value if value is not None else '' 11918 ''' 11919 11920 ''' 11921 11922 def __repr__(self): 11923 return '<sdm.Tag ' + \ 11924 'name: ' + repr(self.name) + ' ' +\ 11925 'value: ' + repr(self.value) + ' ' +\ 11926 '>' 11927 11928 def to_dict(self): 11929 return { 11930 'name': self.name, 11931 'value': self.value, 11932 } 11933 11934 @classmethod 11935 def from_dict(cls, d): 11936 return cls( 11937 name=d.get('name'), 11938 value=d.get('value'), 11939 )
#
name
#
value
View Source
11942class Teradata: 11943 ''' 11944 11945 ''' 11946 __slots__ = [ 11947 'egress_filter', 11948 'healthy', 11949 'hostname', 11950 'id', 11951 'name', 11952 'password', 11953 'port', 11954 'port_override', 11955 'secret_store_id', 11956 'tags', 11957 'username', 11958 ] 11959 11960 def __init__( 11961 self, 11962 egress_filter=None, 11963 healthy=None, 11964 hostname=None, 11965 id=None, 11966 name=None, 11967 password=None, 11968 port=None, 11969 port_override=None, 11970 secret_store_id=None, 11971 tags=None, 11972 username=None, 11973 ): 11974 self.egress_filter = egress_filter if egress_filter is not None else '' 11975 ''' 11976 A filter applied to the routing logic to pin datasource to nodes. 11977 ''' 11978 self.healthy = healthy if healthy is not None else False 11979 ''' 11980 True if the datasource is reachable and the credentials are valid. 11981 ''' 11982 self.hostname = hostname if hostname is not None else '' 11983 ''' 11984 11985 ''' 11986 self.id = id if id is not None else '' 11987 ''' 11988 Unique identifier of the Resource. 11989 ''' 11990 self.name = name if name is not None else '' 11991 ''' 11992 Unique human-readable name of the Resource. 11993 ''' 11994 self.password = password if password is not None else '' 11995 ''' 11996 11997 ''' 11998 self.port = port if port is not None else 0 11999 ''' 12000 12001 ''' 12002 self.port_override = port_override if port_override is not None else 0 12003 ''' 12004 12005 ''' 12006 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 12007 ''' 12008 ID of the secret store containing credentials for this resource, if any. 12009 ''' 12010 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 12011 ''' 12012 Tags is a map of key, value pairs. 12013 ''' 12014 self.username = username if username is not None else '' 12015 ''' 12016 12017 ''' 12018 12019 def __repr__(self): 12020 return '<sdm.Teradata ' + \ 12021 'egress_filter: ' + repr(self.egress_filter) + ' ' +\ 12022 'healthy: ' + repr(self.healthy) + ' ' +\ 12023 'hostname: ' + repr(self.hostname) + ' ' +\ 12024 'id: ' + repr(self.id) + ' ' +\ 12025 'name: ' + repr(self.name) + ' ' +\ 12026 'password: ' + repr(self.password) + ' ' +\ 12027 'port: ' + repr(self.port) + ' ' +\ 12028 'port_override: ' + repr(self.port_override) + ' ' +\ 12029 'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\ 12030 'tags: ' + repr(self.tags) + ' ' +\ 12031 'username: ' + repr(self.username) + ' ' +\ 12032 '>' 12033 12034 def to_dict(self): 12035 return { 12036 'egress_filter': self.egress_filter, 12037 'healthy': self.healthy, 12038 'hostname': self.hostname, 12039 'id': self.id, 12040 'name': self.name, 12041 'password': self.password, 12042 'port': self.port, 12043 'port_override': self.port_override, 12044 'secret_store_id': self.secret_store_id, 12045 'tags': self.tags, 12046 'username': self.username, 12047 } 12048 12049 @classmethod 12050 def from_dict(cls, d): 12051 return cls( 12052 egress_filter=d.get('egress_filter'), 12053 healthy=d.get('healthy'), 12054 hostname=d.get('hostname'), 12055 id=d.get('id'), 12056 name=d.get('name'), 12057 password=d.get('password'), 12058 port=d.get('port'), 12059 port_override=d.get('port_override'), 12060 secret_store_id=d.get('secret_store_id'), 12061 tags=d.get('tags'), 12062 username=d.get('username'), 12063 )
#
Teradata(
egress_filter=None,
healthy=None,
hostname=None,
id=None,
name=None,
password=None,
port=None,
port_override=None,
secret_store_id=None,
tags=None,
username=None
)
View Source
11960 def __init__( 11961 self, 11962 egress_filter=None, 11963 healthy=None, 11964 hostname=None, 11965 id=None, 11966 name=None, 11967 password=None, 11968 port=None, 11969 port_override=None, 11970 secret_store_id=None, 11971 tags=None, 11972 username=None, 11973 ): 11974 self.egress_filter = egress_filter if egress_filter is not None else '' 11975 ''' 11976 A filter applied to the routing logic to pin datasource to nodes. 11977 ''' 11978 self.healthy = healthy if healthy is not None else False 11979 ''' 11980 True if the datasource is reachable and the credentials are valid. 11981 ''' 11982 self.hostname = hostname if hostname is not None else '' 11983 ''' 11984 11985 ''' 11986 self.id = id if id is not None else '' 11987 ''' 11988 Unique identifier of the Resource. 11989 ''' 11990 self.name = name if name is not None else '' 11991 ''' 11992 Unique human-readable name of the Resource. 11993 ''' 11994 self.password = password if password is not None else '' 11995 ''' 11996 11997 ''' 11998 self.port = port if port is not None else 0 11999 ''' 12000 12001 ''' 12002 self.port_override = port_override if port_override is not None else 0 12003 ''' 12004 12005 ''' 12006 self.secret_store_id = secret_store_id if secret_store_id is not None else '' 12007 ''' 12008 ID of the secret store containing credentials for this resource, if any. 12009 ''' 12010 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 12011 ''' 12012 Tags is a map of key, value pairs. 12013 ''' 12014 self.username = username if username is not None else '' 12015 ''' 12016 12017 '''
#
egress_filter
A filter applied to the routing logic to pin datasource to nodes.
#
healthy
True if the datasource is reachable and the credentials are valid.
#
hostname
#
id
Unique identifier of the Resource.
#
name
Unique human-readable name of the Resource.
#
password
#
port
#
port_override
#
secret_store_id
ID of the secret store containing credentials for this resource, if any.
#
username
View Source
12034 def to_dict(self): 12035 return { 12036 'egress_filter': self.egress_filter, 12037 'healthy': self.healthy, 12038 'hostname': self.hostname, 12039 'id': self.id, 12040 'name': self.name, 12041 'password': self.password, 12042 'port': self.port, 12043 'port_override': self.port_override, 12044 'secret_store_id': self.secret_store_id, 12045 'tags': self.tags, 12046 'username': self.username, 12047 }
View Source
12049 @classmethod 12050 def from_dict(cls, d): 12051 return cls( 12052 egress_filter=d.get('egress_filter'), 12053 healthy=d.get('healthy'), 12054 hostname=d.get('hostname'), 12055 id=d.get('id'), 12056 name=d.get('name'), 12057 password=d.get('password'), 12058 port=d.get('port'), 12059 port_override=d.get('port_override'), 12060 secret_store_id=d.get('secret_store_id'), 12061 tags=d.get('tags'), 12062 username=d.get('username'), 12063 )
View Source
12066class UpdateResponseMetadata: 12067 ''' 12068 UpdateResponseMetadata is reserved for future use. 12069 ''' 12070 __slots__ = [] 12071 12072 def __init__(self, ): 12073 pass 12074 12075 def __repr__(self): 12076 return '<sdm.UpdateResponseMetadata ' + \ 12077 '>' 12078 12079 def to_dict(self): 12080 return {} 12081 12082 @classmethod 12083 def from_dict(cls, d): 12084 return cls()
UpdateResponseMetadata is reserved for future use.
View Source
12087class User: 12088 ''' 12089 A User can connect to resources they are granted directly, or granted 12090 via roles. 12091 ''' 12092 __slots__ = [ 12093 'email', 12094 'first_name', 12095 'id', 12096 'last_name', 12097 'suspended', 12098 'tags', 12099 ] 12100 12101 def __init__( 12102 self, 12103 email=None, 12104 first_name=None, 12105 id=None, 12106 last_name=None, 12107 suspended=None, 12108 tags=None, 12109 ): 12110 self.email = email if email is not None else '' 12111 ''' 12112 The User's email address. Must be unique. 12113 ''' 12114 self.first_name = first_name if first_name is not None else '' 12115 ''' 12116 The User's first name. 12117 ''' 12118 self.id = id if id is not None else '' 12119 ''' 12120 Unique identifier of the User. 12121 ''' 12122 self.last_name = last_name if last_name is not None else '' 12123 ''' 12124 The User's last name. 12125 ''' 12126 self.suspended = suspended if suspended is not None else False 12127 ''' 12128 The User's suspended state. 12129 ''' 12130 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 12131 ''' 12132 Tags is a map of key, value pairs. 12133 ''' 12134 12135 def __repr__(self): 12136 return '<sdm.User ' + \ 12137 'email: ' + repr(self.email) + ' ' +\ 12138 'first_name: ' + repr(self.first_name) + ' ' +\ 12139 'id: ' + repr(self.id) + ' ' +\ 12140 'last_name: ' + repr(self.last_name) + ' ' +\ 12141 'suspended: ' + repr(self.suspended) + ' ' +\ 12142 'tags: ' + repr(self.tags) + ' ' +\ 12143 '>' 12144 12145 def to_dict(self): 12146 return { 12147 'email': self.email, 12148 'first_name': self.first_name, 12149 'id': self.id, 12150 'last_name': self.last_name, 12151 'suspended': self.suspended, 12152 'tags': self.tags, 12153 } 12154 12155 @classmethod 12156 def from_dict(cls, d): 12157 return cls( 12158 email=d.get('email'), 12159 first_name=d.get('first_name'), 12160 id=d.get('id'), 12161 last_name=d.get('last_name'), 12162 suspended=d.get('suspended'), 12163 tags=d.get('tags'), 12164 )
A User can connect to resources they are granted directly, or granted via roles.
View Source
12101 def __init__( 12102 self, 12103 email=None, 12104 first_name=None, 12105 id=None, 12106 last_name=None, 12107 suspended=None, 12108 tags=None, 12109 ): 12110 self.email = email if email is not None else '' 12111 ''' 12112 The User's email address. Must be unique. 12113 ''' 12114 self.first_name = first_name if first_name is not None else '' 12115 ''' 12116 The User's first name. 12117 ''' 12118 self.id = id if id is not None else '' 12119 ''' 12120 Unique identifier of the User. 12121 ''' 12122 self.last_name = last_name if last_name is not None else '' 12123 ''' 12124 The User's last name. 12125 ''' 12126 self.suspended = suspended if suspended is not None else False 12127 ''' 12128 The User's suspended state. 12129 ''' 12130 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 12131 ''' 12132 Tags is a map of key, value pairs. 12133 '''
#
email
The User's email address. Must be unique.
#
first_name
The User's first name.
#
id
Unique identifier of the User.
#
last_name
The User's last name.
#
suspended
The User's suspended state.
View Source
12167class VaultAppRoleStore: 12168 ''' 12169 12170 ''' 12171 __slots__ = [ 12172 'id', 12173 'name', 12174 'namespace', 12175 'server_address', 12176 'tags', 12177 ] 12178 12179 def __init__( 12180 self, 12181 id=None, 12182 name=None, 12183 namespace=None, 12184 server_address=None, 12185 tags=None, 12186 ): 12187 self.id = id if id is not None else '' 12188 ''' 12189 Unique identifier of the SecretStore. 12190 ''' 12191 self.name = name if name is not None else '' 12192 ''' 12193 Unique human-readable name of the SecretStore. 12194 ''' 12195 self.namespace = namespace if namespace is not None else '' 12196 ''' 12197 12198 ''' 12199 self.server_address = server_address if server_address is not None else '' 12200 ''' 12201 12202 ''' 12203 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 12204 ''' 12205 Tags is a map of key, value pairs. 12206 ''' 12207 12208 def __repr__(self): 12209 return '<sdm.VaultAppRoleStore ' + \ 12210 'id: ' + repr(self.id) + ' ' +\ 12211 'name: ' + repr(self.name) + ' ' +\ 12212 'namespace: ' + repr(self.namespace) + ' ' +\ 12213 'server_address: ' + repr(self.server_address) + ' ' +\ 12214 'tags: ' + repr(self.tags) + ' ' +\ 12215 '>' 12216 12217 def to_dict(self): 12218 return { 12219 'id': self.id, 12220 'name': self.name, 12221 'namespace': self.namespace, 12222 'server_address': self.server_address, 12223 'tags': self.tags, 12224 } 12225 12226 @classmethod 12227 def from_dict(cls, d): 12228 return cls( 12229 id=d.get('id'), 12230 name=d.get('name'), 12231 namespace=d.get('namespace'), 12232 server_address=d.get('server_address'), 12233 tags=d.get('tags'), 12234 )
View Source
12179 def __init__( 12180 self, 12181 id=None, 12182 name=None, 12183 namespace=None, 12184 server_address=None, 12185 tags=None, 12186 ): 12187 self.id = id if id is not None else '' 12188 ''' 12189 Unique identifier of the SecretStore. 12190 ''' 12191 self.name = name if name is not None else '' 12192 ''' 12193 Unique human-readable name of the SecretStore. 12194 ''' 12195 self.namespace = namespace if namespace is not None else '' 12196 ''' 12197 12198 ''' 12199 self.server_address = server_address if server_address is not None else '' 12200 ''' 12201 12202 ''' 12203 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 12204 ''' 12205 Tags is a map of key, value pairs. 12206 '''
#
id
Unique identifier of the SecretStore.
#
name
Unique human-readable name of the SecretStore.
#
namespace
#
server_address
View Source
12237class VaultTLSStore: 12238 ''' 12239 12240 ''' 12241 __slots__ = [ 12242 'ca_cert_path', 12243 'client_cert_path', 12244 'client_key_path', 12245 'id', 12246 'name', 12247 'namespace', 12248 'server_address', 12249 'tags', 12250 ] 12251 12252 def __init__( 12253 self, 12254 ca_cert_path=None, 12255 client_cert_path=None, 12256 client_key_path=None, 12257 id=None, 12258 name=None, 12259 namespace=None, 12260 server_address=None, 12261 tags=None, 12262 ): 12263 self.ca_cert_path = ca_cert_path if ca_cert_path is not None else '' 12264 ''' 12265 12266 ''' 12267 self.client_cert_path = client_cert_path if client_cert_path is not None else '' 12268 ''' 12269 12270 ''' 12271 self.client_key_path = client_key_path if client_key_path is not None else '' 12272 ''' 12273 12274 ''' 12275 self.id = id if id is not None else '' 12276 ''' 12277 Unique identifier of the SecretStore. 12278 ''' 12279 self.name = name if name is not None else '' 12280 ''' 12281 Unique human-readable name of the SecretStore. 12282 ''' 12283 self.namespace = namespace if namespace is not None else '' 12284 ''' 12285 12286 ''' 12287 self.server_address = server_address if server_address is not None else '' 12288 ''' 12289 12290 ''' 12291 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 12292 ''' 12293 Tags is a map of key, value pairs. 12294 ''' 12295 12296 def __repr__(self): 12297 return '<sdm.VaultTLSStore ' + \ 12298 'ca_cert_path: ' + repr(self.ca_cert_path) + ' ' +\ 12299 'client_cert_path: ' + repr(self.client_cert_path) + ' ' +\ 12300 'client_key_path: ' + repr(self.client_key_path) + ' ' +\ 12301 'id: ' + repr(self.id) + ' ' +\ 12302 'name: ' + repr(self.name) + ' ' +\ 12303 'namespace: ' + repr(self.namespace) + ' ' +\ 12304 'server_address: ' + repr(self.server_address) + ' ' +\ 12305 'tags: ' + repr(self.tags) + ' ' +\ 12306 '>' 12307 12308 def to_dict(self): 12309 return { 12310 'ca_cert_path': self.ca_cert_path, 12311 'client_cert_path': self.client_cert_path, 12312 'client_key_path': self.client_key_path, 12313 'id': self.id, 12314 'name': self.name, 12315 'namespace': self.namespace, 12316 'server_address': self.server_address, 12317 'tags': self.tags, 12318 } 12319 12320 @classmethod 12321 def from_dict(cls, d): 12322 return cls( 12323 ca_cert_path=d.get('ca_cert_path'), 12324 client_cert_path=d.get('client_cert_path'), 12325 client_key_path=d.get('client_key_path'), 12326 id=d.get('id'), 12327 name=d.get('name'), 12328 namespace=d.get('namespace'), 12329 server_address=d.get('server_address'), 12330 tags=d.get('tags'), 12331 )
#
VaultTLSStore(
ca_cert_path=None,
client_cert_path=None,
client_key_path=None,
id=None,
name=None,
namespace=None,
server_address=None,
tags=None
)
View Source
12252 def __init__( 12253 self, 12254 ca_cert_path=None, 12255 client_cert_path=None, 12256 client_key_path=None, 12257 id=None, 12258 name=None, 12259 namespace=None, 12260 server_address=None, 12261 tags=None, 12262 ): 12263 self.ca_cert_path = ca_cert_path if ca_cert_path is not None else '' 12264 ''' 12265 12266 ''' 12267 self.client_cert_path = client_cert_path if client_cert_path is not None else '' 12268 ''' 12269 12270 ''' 12271 self.client_key_path = client_key_path if client_key_path is not None else '' 12272 ''' 12273 12274 ''' 12275 self.id = id if id is not None else '' 12276 ''' 12277 Unique identifier of the SecretStore. 12278 ''' 12279 self.name = name if name is not None else '' 12280 ''' 12281 Unique human-readable name of the SecretStore. 12282 ''' 12283 self.namespace = namespace if namespace is not None else '' 12284 ''' 12285 12286 ''' 12287 self.server_address = server_address if server_address is not None else '' 12288 ''' 12289 12290 ''' 12291 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 12292 ''' 12293 Tags is a map of key, value pairs. 12294 '''
#
ca_cert_path
#
client_cert_path
#
client_key_path
#
id
Unique identifier of the SecretStore.
#
name
Unique human-readable name of the SecretStore.
#
namespace
#
server_address
View Source
12308 def to_dict(self): 12309 return { 12310 'ca_cert_path': self.ca_cert_path, 12311 'client_cert_path': self.client_cert_path, 12312 'client_key_path': self.client_key_path, 12313 'id': self.id, 12314 'name': self.name, 12315 'namespace': self.namespace, 12316 'server_address': self.server_address, 12317 'tags': self.tags, 12318 }
View Source
12320 @classmethod 12321 def from_dict(cls, d): 12322 return cls( 12323 ca_cert_path=d.get('ca_cert_path'), 12324 client_cert_path=d.get('client_cert_path'), 12325 client_key_path=d.get('client_key_path'), 12326 id=d.get('id'), 12327 name=d.get('name'), 12328 namespace=d.get('namespace'), 12329 server_address=d.get('server_address'), 12330 tags=d.get('tags'), 12331 )
View Source
12334class VaultTokenStore: 12335 ''' 12336 12337 ''' 12338 __slots__ = [ 12339 'id', 12340 'name', 12341 'namespace', 12342 'server_address', 12343 'tags', 12344 ] 12345 12346 def __init__( 12347 self, 12348 id=None, 12349 name=None, 12350 namespace=None, 12351 server_address=None, 12352 tags=None, 12353 ): 12354 self.id = id if id is not None else '' 12355 ''' 12356 Unique identifier of the SecretStore. 12357 ''' 12358 self.name = name if name is not None else '' 12359 ''' 12360 Unique human-readable name of the SecretStore. 12361 ''' 12362 self.namespace = namespace if namespace is not None else '' 12363 ''' 12364 12365 ''' 12366 self.server_address = server_address if server_address is not None else '' 12367 ''' 12368 12369 ''' 12370 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 12371 ''' 12372 Tags is a map of key, value pairs. 12373 ''' 12374 12375 def __repr__(self): 12376 return '<sdm.VaultTokenStore ' + \ 12377 'id: ' + repr(self.id) + ' ' +\ 12378 'name: ' + repr(self.name) + ' ' +\ 12379 'namespace: ' + repr(self.namespace) + ' ' +\ 12380 'server_address: ' + repr(self.server_address) + ' ' +\ 12381 'tags: ' + repr(self.tags) + ' ' +\ 12382 '>' 12383 12384 def to_dict(self): 12385 return { 12386 'id': self.id, 12387 'name': self.name, 12388 'namespace': self.namespace, 12389 'server_address': self.server_address, 12390 'tags': self.tags, 12391 } 12392 12393 @classmethod 12394 def from_dict(cls, d): 12395 return cls( 12396 id=d.get('id'), 12397 name=d.get('name'), 12398 namespace=d.get('namespace'), 12399 server_address=d.get('server_address'), 12400 tags=d.get('tags'), 12401 )
View Source
12346 def __init__( 12347 self, 12348 id=None, 12349 name=None, 12350 namespace=None, 12351 server_address=None, 12352 tags=None, 12353 ): 12354 self.id = id if id is not None else '' 12355 ''' 12356 Unique identifier of the SecretStore. 12357 ''' 12358 self.name = name if name is not None else '' 12359 ''' 12360 Unique human-readable name of the SecretStore. 12361 ''' 12362 self.namespace = namespace if namespace is not None else '' 12363 ''' 12364 12365 ''' 12366 self.server_address = server_address if server_address is not None else '' 12367 ''' 12368 12369 ''' 12370 self.tags = tags if tags is not None else _porcelain_zero_value_tags() 12371 ''' 12372 Tags is a map of key, value pairs. 12373 '''
#
id
Unique identifier of the SecretStore.
#
name
Unique human-readable name of the SecretStore.
#
namespace
#
server_address